No eager creation of CanvasResourceProvider when canvas 2d bridge is created

This is a partial revert of the big refactoring CL
https://chromium-review.googlesource.com/c/chromium/src/+/864630. That CL
made the creation of CanvasResourceProvider for canvas 2d earlier at the point
of time when Canvas2DLayerBridge is created; this changed the code paths of
some instances and should not belong to a refactoring CL that is not intended
to change behavior.


Bug: 806066
Change-Id: I00493338f6bda4a9ea17ee01db2dcab29223398c
Reviewed-on: https://chromium-review.googlesource.com/896084Reviewed-by: Justin Novosad <junov@chromium.org>
Commit-Queue: Olivia Lai <xlai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#533820}

third_party/WebKit/Source/core/html/canvas/HTMLCanvasElement.cpp

@@ -1024,7 +1024,7 @@ CanvasResourceProvider* HTMLCanvasElement::ResourceProvider() const {
   return webgl_resource_provider_.get();
 }
 
-void HTMLCanvasElement::CreateResourceProviderInternal(
+void HTMLCanvasElement::CreateImageBufferInternal(
     std::unique_ptr<Canvas2DLayerBridge> external_canvas2d_bridge) {
   DCHECK(!canvas2d_bridge_ && !webgl_resource_provider_);
 
@@ -1047,18 +1047,19 @@ void HTMLCanvasElement::CreateResourceProviderInternal(
     }
   }
 
-  if (canvas2d_bridge_) {
-    canvas2d_bridge_->SetCanvasResourceHost(this);
-    if (!canvas2d_bridge_->GetOrCreateResourceProvider())
-      return;
-  }
-
   if (Is3d()) {
     webgl_resource_provider_ = CanvasResourceProvider::Create(
         size_, CanvasResourceProvider::kAcceleratedResourceUsage,
         SharedGpuContext::ContextProviderWrapper(), 0, ColorParams());
     if (!webgl_resource_provider_)
       return;
+  } else {
+    DCHECK(Is2d());
+    if (canvas2d_bridge_) {
+      canvas2d_bridge_->SetCanvasResourceHost(this);
+    } else {
+      return;
+    }
   }
 
   did_fail_to_create_resource_provider_ = false;
@@ -1128,7 +1129,7 @@ bool HTMLCanvasElement::TryCreateImageBuffer() {
   DCHECK(context_);
   DCHECK(!HasImageBitmapContext());
   if (!HasImageBuffer() && !did_fail_to_create_resource_provider_) {
-    CreateResourceProviderInternal(nullptr);
+    CreateImageBufferInternal(nullptr);
     if (did_fail_to_create_resource_provider_ && Is2d() && !Size().IsEmpty()) {
       context_->LoseContext(CanvasRenderingContext::kSyntheticLostContext);
     }
@@ -1138,15 +1139,11 @@ bool HTMLCanvasElement::TryCreateImageBuffer() {
 
 void HTMLCanvasElement::CreateImageBufferUsingSurfaceForTesting(
     std::unique_ptr<Canvas2DLayerBridge> surface,
-    const IntSize& size,
-    bool is_resource_provider_needed) {
+    const IntSize& size) {
   DiscardImageBuffer();
   SetIntegralAttribute(widthAttr, size.Width());
   SetIntegralAttribute(heightAttr, size.Height());
-  CreateResourceProviderInternal(std::move(surface));
-  if (!is_resource_provider_needed && canvas2d_bridge_) {
-    canvas2d_bridge_->ResetResourceProvider();
-  }
+  CreateImageBufferInternal(std::move(surface));
 }
 
 scoped_refptr<Image> HTMLCanvasElement::CopiedImage(

third_party/WebKit/Source/core/html/canvas/HTMLCanvasElement.h

@@ -226,8 +226,7 @@ class CORE_EXPORT HTMLCanvasElement final
 
   void CreateImageBufferUsingSurfaceForTesting(
       std::unique_ptr<Canvas2DLayerBridge>,
-      const IntSize&,
-      bool is_resource_provider_needed = true);
+      const IntSize&);
 
   static void RegisterRenderingContextFactory(
       std::unique_ptr<CanvasRenderingContextFactory>);
@@ -313,7 +312,7 @@ class CORE_EXPORT HTMLCanvasElement final
   std::unique_ptr<Canvas2DLayerBridge> CreateAccelerated2dBuffer(
       int* msaa_sample_count);
   std::unique_ptr<Canvas2DLayerBridge> CreateUnaccelerated2dBuffer();
-  void CreateResourceProviderInternal(std::unique_ptr<Canvas2DLayerBridge>);
+  void CreateImageBufferInternal(std::unique_ptr<Canvas2DLayerBridge>);
 
   void SetSurfaceSize(const IntSize&);
 

third_party/WebKit/Source/modules/canvas/canvas2d/CanvasRenderingContext2DTest.cpp

@@ -738,6 +738,25 @@ TEST_F(CanvasRenderingContext2DTest, MAYBE_TextureUploadHeuristics) {
   }
 }
 
+TEST_F(CanvasRenderingContext2DTest,
+       NoResourceProviderInCanvas2DBufferInitialization) {
+  // This test enforces that there is no eager creation of
+  // CanvasResourceProvider for html canvas with 2d context when its
+  // Canvas2DLayerBridge is initially set up. This enforcement might be changed
+  // in the future refactoring; but change is seriously warned against because
+  // certain code paths in canvas 2d (that depend on the existence of
+  // CanvasResourceProvider) will be changed too, causing bad regressions.
+  CreateContext(kNonOpaque);
+  IntSize size(10, 10);
+  auto fake_accelerate_surface = std::make_unique<FakeCanvas2DLayerBridge>(
+      size, CanvasColorParams(), kPreferAcceleration);
+  CanvasElement().CreateImageBufferUsingSurfaceForTesting(
+      std::move(fake_accelerate_surface), size);
+
+  EXPECT_TRUE(CanvasElement().Canvas2DBuffer());
+  EXPECT_FALSE(CanvasElement().ResourceProvider());
+}
+
 TEST_F(CanvasRenderingContext2DTest, DisableAcceleration_UpdateGPUMemoryUsage) {
   CreateContext(kNonOpaque);
 
@@ -1171,7 +1190,7 @@ TEST_F(CanvasRenderingContext2DTestWithTestingPlatform,
   // Force hibernatation to occur in an immediate task.
   bridge->DontUseIdleSchedulingForTesting();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(bridge),
-                                                          size, false);
+                                                          size);
 
   EXPECT_TRUE(CanvasElement().Canvas2DBuffer()->IsAccelerated());