Bug 1199371 - Don't create TextureClients for video when the video isn't visible. r=nical

gfx/layers/ImageContainer.cpp

@@ -170,6 +170,7 @@ ImageContainer::ImageContainer(Mode flag)
 : mReentrantMonitor("ImageContainer.mReentrantMonitor"),
   mGenerationCounter(++sGenerationCounter),
   mPaintCount(0),
+  mAttachCount(0),
   mDroppedImageCount(0),
   mImageFactory(new ImageFactory()),
   mRecycleBin(new BufferRecycleBin()),
@@ -234,6 +235,28 @@ ImageContainer::CreateImage(ImageFormat aFormat)
   return mImageFactory->CreateImage(aFormat, mScaleHint, mRecycleBin);
 }
 
+void
+ImageContainer::NotifyAttached()
+{
+  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+  if (!mAttachCount++) {
+    if (IsAsync()) {
+      ImageBridgeChild::DispatchImageClientUpdate(mImageClient, this);
+    }
+  }
+}
+
+void
+ImageContainer::NotifyDetached()
+{
+  ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+  if (!--mAttachCount) {
+    if (IsAsync()) {
+      ImageBridgeChild::FlushAllImagesAsync(mImageClient);
+    }
+  }
+}
+
 void
 ImageContainer::SetCurrentImageInternal(const nsTArray<NonOwningImage>& aImages)
 {

gfx/layers/ImageContainer.h

@@ -388,6 +388,18 @@ public:
    */
   uint64_t GetAsyncContainerID() const;
 
+  /**
+   * We track when ImageContainers are attached to layers so that we can
+   * avoid sending images through ImageBridge if they won't be displayed.
+   */
+  void NotifyAttached();
+  void NotifyDetached();
+
+  bool IsAttached() {
+    ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+    return !!mAttachCount;
+  }
+
   /**
    * Returns if the container currently has an image.
    * Can be called on any thread. This method takes mReentrantMonitor
@@ -519,6 +531,8 @@ private:
   // threadsafe.
   uint32_t mPaintCount;
 
+  int32_t mAttachCount;
+
   // See GetPaintDelay. Accessed only with mReentrantMonitor held.
   TimeDuration mPaintDelay;
 

gfx/layers/ImageLayers.cpp

@@ -19,11 +19,25 @@ ImageLayer::ImageLayer(LayerManager* aManager, void* aImplData)
 {}
 
 ImageLayer::~ImageLayer()
-{}
+{
+  if (mContainer) {
+    mContainer->NotifyDetached();
+  }
+}
 
 void ImageLayer::SetContainer(ImageContainer* aContainer) 
 {
+  if (aContainer == mContainer) {
+    return;
+  }
+
+  if (mContainer) {
+    mContainer->NotifyDetached();
+  }
   mContainer = aContainer;
+  if (mContainer) {
+    mContainer->NotifyAttached();
+  }
 }
 
 void ImageLayer::ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface)

gfx/layers/ipc/ImageBridgeChild.cpp

@@ -407,6 +407,9 @@ static void UpdateImageClientNow(ImageClient* aClient, ImageContainer* aContaine
 {
   MOZ_ASSERT(aClient);
   MOZ_ASSERT(aContainer);
+  if (!aContainer->IsAttached()) {
+    return;
+  }
   sImageBridgeChildSingleton->BeginTransaction();
   aClient->UpdateImage(aContainer, Layer::CONTENT_OPAQUE);
   sImageBridgeChildSingleton->EndTransaction();
@@ -475,6 +478,33 @@ void ImageBridgeChild::FlushAllImages(ImageClient* aClient,
   waiter->WaitComplete();
 }
 
+static void FlushAllImagesAsync(ImageClient* aClient)
+{
+  MOZ_ASSERT(aClient);
+  sImageBridgeChildSingleton->BeginTransaction();
+  aClient->FlushAllImages(nullptr);
+  sImageBridgeChildSingleton->EndTransaction();
+}
+
+//static
+void ImageBridgeChild::FlushAllImagesAsync(ImageClient* aClient)
+{
+  if (!IsCreated()) {
+    return;
+  }
+  MOZ_ASSERT(aClient);
+  MOZ_ASSERT(!sImageBridgeChildSingleton->mShuttingDown);
+  MOZ_ASSERT(!InImageBridgeChildThread());
+  if (InImageBridgeChildThread()) {
+    NS_ERROR("ImageBridgeChild::FlushAllImages() is called on ImageBridge thread.");
+    return;
+  }
+
+  sImageBridgeChildSingleton->GetMessageLoop()->PostTask(
+    FROM_HERE,
+    NewRunnableFunction(&FlushAllImagesAsync, aClient));
+}
+
 void
 ImageBridgeChild::BeginTransaction()
 {

gfx/layers/ipc/ImageBridgeChild.h

@@ -221,6 +221,8 @@ public:
    */
   static void FlushAllImages(ImageClient* aClient, ImageContainer* aContainer);
 
+  static void FlushAllImagesAsync(ImageClient* aClient);
+
   // CompositableForwarder
 
   virtual void Connect(CompositableClient* aCompositable,