/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef GFX_CLIENTLAYERMANAGER_H #define GFX_CLIENTLAYERMANAGER_H #include "Layers.h" #include "mozilla/layers/ShadowLayers.h" namespace mozilla { namespace layers { class ClientLayerManager : public LayerManager, public ShadowLayerForwarder { typedef nsTArray > LayerRefArray; public: ClientLayerManager(nsIWidget* aWidget); virtual ~ClientLayerManager(); virtual ShadowLayerForwarder* AsShadowForwarder() { return this; } virtual int32_t GetMaxTextureSize() const; virtual void SetDefaultTargetConfiguration(BufferMode aDoubleBuffering, ScreenRotation aRotation); virtual void BeginTransactionWithTarget(gfxContext* aTarget); virtual void BeginTransaction(); virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT); virtual void EndTransaction(DrawThebesLayerCallback aCallback, void* aCallbackData, EndTransactionFlags aFlags = END_DEFAULT); virtual LayersBackend GetBackendType() { return LAYERS_CLIENT; } virtual void GetBackendName(nsAString& name); #ifdef MOZ_LAYERS_HAVE_LOG virtual const char* Name() const { return "Client"; } #endif // MOZ_LAYERS_HAVE_LOG virtual void SetRoot(Layer* aLayer); virtual void Mutated(Layer* aLayer); virtual already_AddRefed CreateThebesLayer(); virtual already_AddRefed CreateContainerLayer(); virtual already_AddRefed CreateImageLayer(); virtual already_AddRefed CreateCanvasLayer(); virtual already_AddRefed CreateColorLayer(); virtual already_AddRefed CreateRefLayer(); virtual TextureFactoryIdentifier GetTextureFactoryIdentifier() MOZ_OVERRIDE { return mTextureFactoryIdentifier; } virtual void FlushRendering() MOZ_OVERRIDE; virtual bool NeedsWidgetInvalidation() MOZ_OVERRIDE { return false; } ShadowableLayer* Hold(Layer* aLayer); bool HasShadowManager() const { return ShadowLayerForwarder::HasShadowManager(); } virtual bool IsCompositingCheap(); virtual bool HasShadowManagerInternal() const { return HasShadowManager(); } virtual void SetIsFirstPaint() MOZ_OVERRIDE; // Drop cached resources and ask our shadow manager to do the same, // if we have one. virtual void ClearCachedResources(Layer* aSubtree = nullptr) MOZ_OVERRIDE; void SetRepeatTransaction() { mRepeatTransaction = true; } bool GetRepeatTransaction() { return mRepeatTransaction; } bool IsRepeatTransaction() { return mIsRepeatTransaction; } void SetTransactionIncomplete() { mTransactionIncomplete = true; } bool HasShadowTarget() { return !!mShadowTarget; } void SetShadowTarget(gfxContext *aTarget) { mShadowTarget = aTarget; } bool CompositorMightResample() { return mCompositorMightResample; } DrawThebesLayerCallback GetThebesLayerCallback() const { return mThebesLayerCallback; } void* GetThebesLayerCallbackData() const { return mThebesLayerCallbackData; } CompositorChild *GetRemoteRenderer(); /** * Called for each iteration of a progressive tile update. Fills * aViewport, aScaleX and aScaleY with the current scale and viewport * being used to composite the layers in this manager, to determine what area * intersects with the target render rectangle. aDrawingCritical will be * true if the current drawing operation is using the critical displayport. * Returns true if the update should continue, or false if it should be * cancelled. * This is only called if gfxPlatform::UseProgressiveTilePainting() returns * true. */ bool ProgressiveUpdateCallback(bool aHasPendingNewThebesContent, gfx::Rect& aViewport, float& aScaleX, float& aScaleY, bool aDrawingCritical); #ifdef DEBUG bool InConstruction() { return mPhase == PHASE_CONSTRUCTION; } bool InDrawing() { return mPhase == PHASE_DRAWING; } bool InForward() { return mPhase == PHASE_FORWARD; } #endif bool InTransaction() { return mPhase != PHASE_NONE; } protected: enum TransactionPhase { PHASE_NONE, PHASE_CONSTRUCTION, PHASE_DRAWING, PHASE_FORWARD }; TransactionPhase mPhase; private: /** * Forward transaction results to the parent context. */ void ForwardTransaction(); /** * Take a snapshot of the parent context, and copy * it into mShadowTarget. */ void MakeSnapshotIfRequired(); void ClearLayer(Layer* aLayer); bool EndTransactionInternal(DrawThebesLayerCallback aCallback, void* aCallbackData, EndTransactionFlags); // The bounds of |mTarget| in device pixels. nsIntRect mTargetBounds; LayerRefArray mKeepAlive; nsIWidget* mWidget; /* Thebes layer callbacks; valid at the end of a transaciton, * while rendering */ DrawThebesLayerCallback mThebesLayerCallback; void *mThebesLayerCallbackData; // When we're doing a transaction in order to draw to a non-default // target, the layers transaction is only performed in order to send // a PLayers:Update. We save the original non-default target to // mShadowTarget, and then perform the transaction using // mDummyTarget as the render target. After the transaction ends, // we send a message to our remote side to capture the actual pixels // being drawn to the default target, and then copy those pixels // back to mShadowTarget. nsRefPtr mShadowTarget; // Sometimes we draw to targets that don't natively support // landscape/portrait orientation. When we need to implement that // ourselves, |mTargetRotation| describes the induced transform we // need to apply when compositing content to our target. ScreenRotation mTargetRotation; // Used to repeat the transaction right away (to avoid rebuilding // a display list) to support progressive drawing. bool mRepeatTransaction; bool mIsRepeatTransaction; bool mTransactionIncomplete; bool mCompositorMightResample; }; class ClientThebesLayer; class ClientLayer : public ShadowableLayer { public: ClientLayer() { MOZ_COUNT_CTOR(ClientLayer); } ~ClientLayer(); void SetShadow(PLayerChild* aShadow) { NS_ABORT_IF_FALSE(!mShadow, "can't have two shadows (yet)"); mShadow = aShadow; } virtual void Disconnect() { // This is an "emergency Disconnect()", called when the compositing // process has died. |mShadow| and our Shmem buffers are // automatically managed by IPDL, so we don't need to explicitly // free them here (it's hard to get that right on emergency // shutdown anyway). mShadow = nullptr; } virtual void ClearCachedResources() { } virtual void RenderLayer() = 0; virtual ClientThebesLayer* AsThebes() { return nullptr; } static inline ClientLayer * ToClientLayer(Layer* aLayer) { return static_cast(aLayer->ImplData()); } }; // Create a shadow layer (PLayerChild) for aLayer, if we're forwarding // our layer tree to a parent process. Record the new layer creation // in the current open transaction as a side effect. template void CreateShadowFor(ClientLayer* aLayer, ClientLayerManager* aMgr, CreatedMethod aMethod) { PLayerChild* shadow = aMgr->ConstructShadowFor(aLayer); // XXX error handling NS_ABORT_IF_FALSE(shadow, "failed to create shadow"); aLayer->SetShadow(shadow); (aMgr->*aMethod)(aLayer); aMgr->Hold(aLayer->AsLayer()); } #define CREATE_SHADOW(_type) \ CreateShadowFor(layer, this, \ &ShadowLayerForwarder::Created ## _type ## Layer) } } #endif /* GFX_CLIENTLAYERMANAGER_H */