canvas2d: Fix TextureLayer update tracking after canvas hibernation.

Canvas2DLayerBridge keeps track of the current resource on the
cc::TextureLayer to avoid unnecessary updates to the layer's resource if
it was not updated. But it missed a case where the TextureLayer's
resource was being cleared if the canvas is made invisible after
hibernation.

Avoid the above by simply asking the layer for its current resource
instead of mirroring that state in Canvas2DLayerBridge and running into
issues if we can't keep them consistent.

R=enne@chromium.org,fserb@chromium.org

Bug: 977474
Change-Id: I6850115ffc019d7148a4dad40f97bb66029aa4d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1680296Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: Fernando Serboncini <fserb@chromium.org>
Auto-Submit: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#673423}

cc/layers/texture_layer.h

@@ -175,6 +175,11 @@ class CC_EXPORT TextureLayer : public Layer, SharedBitmapIdRegistrar {
       const viz::SharedBitmapId& id,
       scoped_refptr<CrossThreadSharedBitmap> bitmap) override;
 
+  viz::TransferableResource current_transferable_resource() const {
+    return holder_ref_ ? holder_ref_->holder()->resource()
+                       : viz::TransferableResource();
+  }
+
  protected:
   explicit TextureLayer(TextureLayerClient* client);
   ~TextureLayer() override;

third_party/blink/renderer/platform/graphics/canvas_2d_layer_bridge.cc

@@ -587,7 +587,7 @@ bool Canvas2DLayerBridge::PrepareTransferableResource(
   // Note frame is kept alive via a reference kept in out_release_callback.
   if (!frame->PrepareTransferableResource(out_resource, out_release_callback,
                                           kUnverifiedSyncToken) ||
-      *out_resource == previous_frame_resource_) {
+      *out_resource == layer_->current_transferable_resource()) {
     // If the resource did not change, the release will be handled correctly
     // when the callback from the previous frame is dispatched. But run the
     // |out_release_callback| to release the ref acquired above.
@@ -596,7 +596,6 @@ bool Canvas2DLayerBridge::PrepareTransferableResource(
     return false;
   }
 
-  previous_frame_resource_ = *out_resource;
   return true;
 }
 

third_party/blink/renderer/platform/graphics/canvas_2d_layer_bridge.h

@@ -132,6 +132,8 @@ class PLATFORM_EXPORT Canvas2DLayerBridge : public cc::TextureLayerClient {
 
   scoped_refptr<StaticBitmapImage> NewImageSnapshot(AccelerationHint);
 
+  cc::TextureLayer* layer_for_testing() { return layer_.get(); }
+
   // The values of the enum entries must not change because they are used for
   // usage metrics histograms. New values can be added to the end.
   enum HibernationEvent {
@@ -206,7 +208,6 @@ class PLATFORM_EXPORT Canvas2DLayerBridge : public cc::TextureLayerClient {
   mutable SnapshotState snapshot_state_;
 
   CanvasResourceHost* resource_host_;
-  viz::TransferableResource previous_frame_resource_;
 
   base::WeakPtrFactory<Canvas2DLayerBridge> weak_ptr_factory_;
 

third_party/blink/renderer/platform/graphics/canvas_2d_layer_bridge_test.cc

@@ -32,6 +32,7 @@
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
+#include "cc/layers/texture_layer.h"
 #include "cc/test/skia_common.h"
 #include "cc/test/stub_decode_cache.h"
 #include "components/viz/common/resources/single_release_callback.h"
@@ -1372,17 +1373,18 @@ TEST_F(Canvas2DLayerBridgeTestNoMockGL,
 
   bridge->Canvas()->clear(SK_ColorRED);
   DrawSomething(bridge.get());
+  ASSERT_TRUE(bridge->layer_for_testing());
 
   viz::TransferableResource resource;
   std::unique_ptr<viz::SingleReleaseCallback> release_callback;
   EXPECT_TRUE(bridge->PrepareTransferableResource(nullptr, &resource,
                                                   &release_callback));
+  bridge->layer_for_testing()->SetTransferableResource(
+      resource, std::move(release_callback));
 
   std::unique_ptr<viz::SingleReleaseCallback> release_callback2;
   EXPECT_FALSE(bridge->PrepareTransferableResource(nullptr, &resource,
                                                    &release_callback2));
-
-  release_callback->Run(gpu::SyncToken(), false);
   EXPECT_EQ(release_callback2, nullptr);
 }