Attach Compositables to TextureSourceProviders instead of Compositors. (bug 1343814 part 5, r=mattwoodrow)

--HG--
extra : rebase_source : 323b92ae955a55879ce547a6e131e1900a0102d9

gfx/layers/Compositor.h

@@ -533,7 +533,7 @@ public:
   // A stale Compositor has no CompositorBridgeParent; it will not process
   // frames and should not be used.
   void SetInvalid();
-  virtual bool IsValid() const;
+  virtual bool IsValid() const override;
   CompositorBridgeParent* GetCompositorBridgeParent() const {
     return mParent;
   }

gfx/layers/LayerScope.cpp

@@ -918,7 +918,8 @@ SenderHelper::SendLayer(LayerComposite* aLayer,
         case Layer::TYPE_PAINTED: {
             // Get CompositableHost and Compositor
             CompositableHost* compHost = aLayer->GetCompositableHost();
-            Compositor* comp = compHost->GetCompositor();
+            TextureSourceProvider* provider = compHost->GetTextureSourceProvider();
+            Compositor* comp = provider->AsCompositor();
             // Send EffectChain only for CompositorOGL
             if (LayersBackend::LAYERS_OPENGL == comp->GetBackendType()) {
                 CompositorOGL* compOGL = comp->AsCompositorOGL();

gfx/layers/TextureSourceProvider.h

@@ -98,6 +98,10 @@ public:
 
   virtual int32_t GetMaxTextureSize() const = 0;
 
+  // Return whether or not this provider is still valid (i.e., is still being
+  // used to composite).
+  virtual bool IsValid() const = 0;
+
 protected:
   // Should be called at the end of each composition.
   void ReadUnlockTextures();

gfx/layers/composite/CanvasLayerComposite.cpp

@@ -64,7 +64,7 @@ CanvasLayerComposite::SetLayerManager(HostLayerManager* aManager)
   LayerComposite::SetLayerManager(aManager);
   mManager = aManager;
   if (mCompositableHost && mCompositor) {
-    mCompositableHost->SetCompositor(mCompositor);
+    mCompositableHost->SetTextureSourceProvider(mCompositor);
   }
 }
 

gfx/layers/composite/CompositableHost.cpp

@@ -32,7 +32,6 @@ class Compositor;
 CompositableHost::CompositableHost(const TextureInfo& aTextureInfo)
   : mTextureInfo(aTextureInfo)
   , mCompositorID(0)
-  , mCompositor(nullptr)
   , mLayer(nullptr)
   , mFlashCounter(0)
   , mAttached(false)
@@ -49,9 +48,9 @@ CompositableHost::~CompositableHost()
 void
 CompositableHost::UseTextureHost(const nsTArray<TimedTexture>& aTextures)
 {
-  if (GetCompositor()) {
+  if (mTextureSourceProvider) {
     for (auto& texture : aTextures) {
-      texture.mTexture->SetTextureSourceProvider(GetCompositor());
+      texture.mTexture->SetTextureSourceProvider(mTextureSourceProvider);
     }
   }
 }
@@ -61,9 +60,9 @@ CompositableHost::UseComponentAlphaTextures(TextureHost* aTextureOnBlack,
                                             TextureHost* aTextureOnWhite)
 {
   MOZ_ASSERT(aTextureOnBlack && aTextureOnWhite);
-  if (GetCompositor()) {
-    aTextureOnBlack->SetTextureSourceProvider(GetCompositor());
-    aTextureOnWhite->SetTextureSourceProvider(GetCompositor());
+  if (mTextureSourceProvider) {
+    aTextureOnBlack->SetTextureSourceProvider(mTextureSourceProvider);
+    aTextureOnWhite->SetTextureSourceProvider(mTextureSourceProvider);
   }
 }
 
@@ -72,10 +71,10 @@ CompositableHost::RemoveTextureHost(TextureHost* aTexture)
 {}
 
 void
-CompositableHost::SetCompositor(Compositor* aCompositor)
+CompositableHost::SetTextureSourceProvider(TextureSourceProvider* aProvider)
 {
-  MOZ_ASSERT(aCompositor);
-  mCompositor = aCompositor;
+  MOZ_ASSERT(aProvider);
+  mTextureSourceProvider = aProvider;
 }
 
 bool
@@ -175,5 +174,11 @@ CompositableHost::GetLayerManager() const
   return mLayer->Manager()->AsHostLayerManager();
 }
 
+TextureSourceProvider*
+CompositableHost::GetTextureSourceProvider() const
+{
+  return mTextureSourceProvider;
+}
+
 } // namespace layers
 } // namespace mozilla

gfx/layers/composite/CompositableHost.h

@@ -91,7 +91,7 @@ public:
   virtual CompositableType GetType() = 0;
 
   // If base class overrides, it should still call the parent implementation
-  virtual void SetCompositor(Compositor* aCompositor);
+  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider);
 
   // composite the contents of this buffer host to the compositor's surface
   virtual void Composite(Compositor* aCompositor,
@@ -140,10 +140,7 @@ public:
 
   void RemoveMaskEffect();
 
-  Compositor* GetCompositor() const
-  {
-    return mCompositor;
-  }
+  TextureSourceProvider* GetTextureSourceProvider() const;
 
   Layer* GetLayer() const { return mLayer; }
   void SetLayer(Layer* aLayer) { mLayer = aLayer; }
@@ -157,13 +154,13 @@ public:
   static const AttachFlags FORCE_DETACH = 2;
 
   virtual void Attach(Layer* aLayer,
-                      Compositor* aCompositor,
+                      TextureSourceProvider* aProvider,
                       AttachFlags aFlags = NO_FLAGS)
   {
-    MOZ_ASSERT(aCompositor, "Compositor is required");
+    MOZ_ASSERT(aProvider);
     NS_ASSERTION(aFlags & ALLOW_REATTACH || !mAttached,
                  "Re-attaching compositables must be explicitly authorised");
-    SetCompositor(aCompositor);
+    SetTextureSourceProvider(aProvider);
     SetLayer(aLayer);
     mAttached = true;
     mKeepAttached = aFlags & KEEP_ATTACHED;
@@ -244,7 +241,7 @@ protected:
   TextureInfo mTextureInfo;
   AsyncCompositableRef mAsyncRef;
   uint64_t mCompositorID;
-  RefPtr<Compositor> mCompositor;
+  RefPtr<TextureSourceProvider> mTextureSourceProvider;
   Layer* mLayer;
   uint32_t mFlashCounter; // used when the pref "layers.flash-borders" is true.
   bool mAttached;

gfx/layers/composite/ContentHost.cpp

@@ -255,14 +255,14 @@ ContentHostTexture::UseComponentAlphaTextures(TextureHost* aTextureOnBlack,
 }
 
 void
-ContentHostTexture::SetCompositor(Compositor* aCompositor)
+ContentHostTexture::SetTextureSourceProvider(TextureSourceProvider* aProvider)
 {
-  ContentHostBase::SetCompositor(aCompositor);
+  ContentHostBase::SetTextureSourceProvider(aProvider);
   if (mTextureHost) {
-    mTextureHost->SetTextureSourceProvider(aCompositor);
+    mTextureHost->SetTextureSourceProvider(aProvider);
   }
   if (mTextureHostOnWhite) {
-    mTextureHostOnWhite->SetTextureSourceProvider(aCompositor);
+    mTextureHostOnWhite->SetTextureSourceProvider(aProvider);
   }
 }
 

gfx/layers/composite/ContentHost.h

@@ -127,7 +127,7 @@ public:
                          const nsIntRegion* aVisibleRegion = nullptr,
                          const Maybe<gfx::Polygon>& aGeometry = Nothing()) override;
 
-  virtual void SetCompositor(Compositor* aCompositor) override;
+  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider);
 
   virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
 

gfx/layers/composite/ImageHost.cpp

@@ -177,12 +177,12 @@ ImageHost::GetAsTextureHost(IntRect* aPictureRect)
 }
 
 void ImageHost::Attach(Layer* aLayer,
-                       Compositor* aCompositor,
+                       TextureSourceProvider* aProvider,
                        AttachFlags aFlags)
 {
-  CompositableHost::Attach(aLayer, aCompositor, aFlags);
+  CompositableHost::Attach(aLayer, aProvider, aFlags);
   for (auto& img : mImages) {
-    img.mTextureHost->SetTextureSourceProvider(aCompositor);
+    img.mTextureHost->SetTextureSourceProvider(aProvider);
     img.mTextureHost->Updated();
   }
 }
@@ -343,14 +343,14 @@ ImageHost::Composite(Compositor* aCompositor,
 }
 
 void
-ImageHost::SetCompositor(Compositor* aCompositor)
+ImageHost::SetTextureSourceProvider(TextureSourceProvider* aProvider)
 {
-  if (mCompositor != aCompositor) {
+  if (mTextureSourceProvider != aProvider) {
     for (auto& img : mImages) {
-      img.mTextureHost->SetTextureSourceProvider(aCompositor);
+      img.mTextureHost->SetTextureSourceProvider(aProvider);
     }
   }
-  CompositableHost::SetCompositor(aCompositor);
+  CompositableHost::SetTextureSourceProvider(aProvider);
 }
 
 void

gfx/layers/composite/ImageHost.h

@@ -62,10 +62,10 @@ public:
   virtual TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override;
 
   virtual void Attach(Layer* aLayer,
-                      Compositor* aCompositor,
+                      TextureSourceProvider* aProvider,
                       AttachFlags aFlags = NO_FLAGS) override;
 
-  virtual void SetCompositor(Compositor* aCompositor) override;
+  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
 
   gfx::IntSize GetImageSize() const override;
 

gfx/layers/composite/ImageLayerComposite.cpp

@@ -76,7 +76,7 @@ ImageLayerComposite::SetLayerManager(HostLayerManager* aManager)
   LayerComposite::SetLayerManager(aManager);
   mManager = aManager;
   if (mImageHost) {
-    mImageHost->SetCompositor(mCompositor);
+    mImageHost->SetTextureSourceProvider(mCompositor);
   }
 }
 
@@ -101,7 +101,7 @@ ImageLayerComposite::RenderLayer(const IntRect& aClipRect,
 
   RenderWithAllMasks(this, mCompositor, aClipRect,
                      [&](EffectChain& effectChain, const IntRect& clipRect) {
-    mImageHost->SetCompositor(mCompositor);
+    mImageHost->SetTextureSourceProvider(mCompositor);
     mImageHost->Composite(mCompositor, this, effectChain,
                           GetEffectiveOpacity(),
                           GetEffectiveTransformForBuffer(),

gfx/layers/composite/LayerManagerComposite.h

@@ -116,6 +116,7 @@ public:
   virtual void BeginTransactionWithDrawTarget(gfx::DrawTarget* aTarget,
                                               const gfx::IntRect& aRect) = 0;
   virtual Compositor* GetCompositor() const = 0;
+  virtual TextureSourceProvider* GetTextureSourceProvider() const = 0;
   virtual void EndTransaction(const TimeStamp& aTimeStamp,
                               EndTransactionFlags aFlags = END_DEFAULT) = 0;
   virtual void UpdateRenderBounds(const gfx::IntRect& aRect) {}
@@ -357,8 +358,10 @@ public:
     return mVisibleRegions.Get(aGuid);
   }
 
-  Compositor* GetCompositor() const override
-  {
+  Compositor* GetCompositor() const override {
+    return mCompositor;
+  }
+  TextureSourceProvider* GetTextureSourceProvider() const override {
     return mCompositor;
   }
 

gfx/layers/composite/PaintedLayerComposite.cpp

@@ -85,7 +85,7 @@ PaintedLayerComposite::SetLayerManager(HostLayerManager* aManager)
   LayerComposite::SetLayerManager(aManager);
   mManager = aManager;
   if (mBuffer && mCompositor) {
-    mBuffer->SetCompositor(mCompositor);
+    mBuffer->SetTextureSourceProvider(mCompositor);
   }
 }
 
@@ -101,7 +101,7 @@ PaintedLayerComposite::RenderLayer(const gfx::IntRect& aClipRect,
 
   Compositor* compositor = mCompositeManager->GetCompositor();
 
-  MOZ_ASSERT(mBuffer->GetCompositor() == compositor &&
+  MOZ_ASSERT(mBuffer->GetTextureSourceProvider() == compositor &&
              mBuffer->GetLayer() == this,
              "buffer is corrupted");
 

gfx/layers/composite/TiledContentHost.cpp

@@ -57,14 +57,14 @@ TiledLayerBufferComposite::~TiledLayerBufferComposite()
 }
 
 void
-TiledLayerBufferComposite::SetCompositor(Compositor* aCompositor)
+TiledLayerBufferComposite::SetTextureSourceProvider(TextureSourceProvider* aProvider)
 {
-  MOZ_ASSERT(aCompositor);
+  MOZ_ASSERT(aProvider);
   for (TileHost& tile : mRetainedTiles) {
     if (tile.IsPlaceholderTile()) continue;
-    tile.mTextureHost->SetTextureSourceProvider(aCompositor);
+    tile.mTextureHost->SetTextureSourceProvider(aProvider);
     if (tile.mTextureHostOnWhite) {
-      tile.mTextureHostOnWhite->SetTextureSourceProvider(aCompositor);
+      tile.mTextureHostOnWhite->SetTextureSourceProvider(aProvider);
     }
   }
 }
@@ -116,10 +116,10 @@ TiledContentHost::GenEffect(const gfx::SamplingFilter aSamplingFilter)
 
 void
 TiledContentHost::Attach(Layer* aLayer,
-                         Compositor* aCompositor,
+                         TextureSourceProvider* aProvider,
                          AttachFlags aFlags /* = NO_FLAGS */)
 {
-  CompositableHost::Attach(aLayer, aCompositor, aFlags);
+  CompositableHost::Attach(aLayer, aProvider, aFlags);
 }
 
 void

gfx/layers/composite/TiledContentHost.h

@@ -136,7 +136,7 @@ public:
   // by the sum of the resolutions of all parent layers' FrameMetrics.
   const CSSToParentLayerScale2D& GetFrameResolution() { return mFrameResolution; }
 
-  void SetCompositor(Compositor* aCompositor);
+  void SetTextureSourceProvider(TextureSourceProvider* aProvider);
 
   void AddAnimationInvalidation(nsIntRegion& aRegion);
 protected:
@@ -194,12 +194,11 @@ public:
     return mTiledBuffer.GetValidRegion();
   }
 
-  virtual void SetCompositor(Compositor* aCompositor) override
+  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override
   {
-    MOZ_ASSERT(aCompositor);
-    CompositableHost::SetCompositor(aCompositor);
-    mTiledBuffer.SetCompositor(aCompositor);
-    mLowPrecisionTiledBuffer.SetCompositor(aCompositor);
+    CompositableHost::SetTextureSourceProvider(aProvider);
+    mTiledBuffer.SetTextureSourceProvider(aProvider);
+    mLowPrecisionTiledBuffer.SetTextureSourceProvider(aProvider);
   }
 
   bool UseTiledLayerBuffer(ISurfaceAllocator* aAllocator,
@@ -220,7 +219,7 @@ public:
   virtual TiledContentHost* AsTiledContentHost() override { return this; }
 
   virtual void Attach(Layer* aLayer,
-                      Compositor* aCompositor,
+                      TextureSourceProvider* aProvider,
                       AttachFlags aFlags = NO_FLAGS) override;
 
   virtual void Detach(Layer* aLayer = nullptr,

gfx/layers/ipc/CompositableTransactionParent.cpp

@@ -69,8 +69,10 @@ CompositableParentManager::ReceiveCompositableUpdate(const CompositableOperation
   if (!compositable) {
     return false;
   }
-  if (compositable->GetCompositor() && !compositable->GetCompositor()->IsValid()) {
-    return true;
+  if (TextureSourceProvider* provider = compositable->GetTextureSourceProvider()) {
+    if (!provider->IsValid()) {
+      return false;
+    }
   }
 
   switch (aEdit.detail().type()) {

gfx/layers/ipc/LayerTransactionParent.cpp

@@ -873,15 +873,15 @@ LayerTransactionParent::Attach(Layer* aLayer,
     return false;
   }
 
-  Compositor* compositor
-    = static_cast<HostLayerManager*>(aLayer->Manager())->GetCompositor();
+  TextureSourceProvider* provider =
+    static_cast<HostLayerManager*>(aLayer->Manager())->GetTextureSourceProvider();
 
   if (!layer->SetCompositableHost(aCompositable)) {
     // not all layer types accept a compositable, see bug 967824
     return false;
   }
   aCompositable->Attach(aLayer,
-                        compositor,
+                        provider,
                         aIsAsync
                           ? CompositableHost::ALLOW_REATTACH
                             | CompositableHost::KEEP_ATTACHED

gfx/layers/wr/WebRenderImageHost.cpp

@@ -107,7 +107,7 @@ WebRenderImageHost::GetAsTextureHost(IntRect* aPictureRect)
 }
 
 void WebRenderImageHost::Attach(Layer* aLayer,
-                       Compositor* aCompositor,
+                       TextureSourceProvider* aProvider,
                        AttachFlags aFlags)
 {
   MOZ_ASSERT_UNREACHABLE("unexpected to be called");
@@ -128,14 +128,14 @@ WebRenderImageHost::Composite(Compositor* aCompositor,
 }
 
 void
-WebRenderImageHost::SetCompositor(Compositor* aCompositor)
+WebRenderImageHost::SetTextureSourceProvider(TextureSourceProvider* aProvider)
 {
-  if (mCompositor != aCompositor) {
+  if (mTextureSourceProvider != aProvider) {
     for (auto& img : mImages) {
-      img.mTextureHost->SetTextureSourceProvider(aCompositor);
+      img.mTextureHost->SetTextureSourceProvider(aProvider);
     }
   }
-  CompositableHost::SetCompositor(aCompositor);
+  CompositableHost::SetTextureSourceProvider(aProvider);
 }
 
 void

gfx/layers/wr/WebRenderImageHost.h

@@ -42,10 +42,10 @@ public:
   virtual TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override;
 
   virtual void Attach(Layer* aLayer,
-                      Compositor* aCompositor,
+                      TextureSourceProvider* aProvider,
                       AttachFlags aFlags = NO_FLAGS) override;
 
-  virtual void SetCompositor(Compositor* aCompositor) override;
+  virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
 
   gfx::IntSize GetImageSize() const override;