CanvasResourceProvider: add unit tests

This CL adds CanvasResourceProvider unit tests.

Also removes unused method InvalidateSurface().

Bug: 902585
Change-Id: I6602624ea4826d8cd307e4d973430e6c451aebd0
Reviewed-on: https://chromium-review.googlesource.com/c/1334148Reviewed-by: Andres Calderon Jaramillo <andrescj@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Commit-Queue: Miguel Casas <mcasas@chromium.org>
Cr-Commit-Position: refs/heads/master@{#607773}

third_party/blink/renderer/platform/BUILD.gn

@@ -2103,6 +2103,7 @@ jumbo_source_set("unit_tests") {
     "graphics/canvas_2d_layer_bridge_test.cc",
     "graphics/canvas_color_params_test.cc",
     "graphics/canvas_resource_dispatcher_test.cc",
+    "graphics/canvas_resource_provider_test.cc",
     "graphics/canvas_resource_test.cc",
     "graphics/color_correction_test_utils.cc",
     "graphics/deferred_image_decoder_test.cc",

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

@@ -79,7 +79,7 @@ class CanvasResourceProviderTexture : public CanvasResourceProvider {
       // A readback operation may alter the texture parameters, which may affect
       // the compositor's behavior. Therefore, we must trigger copy-on-write
       // even though we are not technically writing to the texture, only to its
-      // parameters.
+      // parameters. This issue is Android-WebView specific: crbug.com/585250.
       // If this issue with readback affecting state is ever fixed, then we'll
       // have to do this instead of triggering a copy-on-write:
       // static_cast<AcceleratedStaticBitmapImage*>(image.get())
@@ -733,13 +733,6 @@ void CanvasResourceProvider::Clear() {
     Canvas()->clear(SK_ColorTRANSPARENT);
 }
 
-void CanvasResourceProvider::InvalidateSurface() {
-  canvas_ = nullptr;
-  canvas_image_provider_.reset();
-  xform_canvas_ = nullptr;
-  surface_ = nullptr;
-}
-
 uint32_t CanvasResourceProvider::ContentUniqueID() const {
   return GetSkSurface()->generationID();
 }

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

@@ -156,10 +156,6 @@ class PLATFORM_EXPORT CanvasResourceProvider
     return weak_ptr_factory_.GetWeakPtr();
   }
 
-  // Called by subclasses when the backing resource has changed and resources
-  // are not managed by skia, signaling that a new surface needs to be created.
-  void InvalidateSurface();
-
   CanvasResourceProvider(const IntSize&,
                          const CanvasColorParams&,
                          base::WeakPtr<WebGraphicsContext3DProviderWrapper>,

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

+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "third_party/blink/renderer/platform/graphics/canvas_resource_provider.h"
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/platform/graphics/canvas_color_params.h"
+#include "third_party/blink/renderer/platform/graphics/canvas_resource_dispatcher.h"
+#include "third_party/blink/renderer/platform/graphics/gpu/shared_gpu_context.h"
+#include "third_party/blink/renderer/platform/graphics/test/fake_gles2_interface.h"
+#include "third_party/blink/renderer/platform/graphics/test/fake_web_graphics_context_3d_provider.h"
+#include "third_party/blink/renderer/platform/wtf/functional.h"
+
+using testing::InSequence;
+using testing::Test;
+
+namespace blink {
+
+class MockCanvasResourceDispatcherClient
+    : public CanvasResourceDispatcherClient {
+ public:
+  MockCanvasResourceDispatcherClient() = default;
+
+  MOCK_METHOD0(BeginFrame, void());
+};
+
+class CanvasResourceProviderTest : public Test {
+ public:
+  void SetUp() override {
+    // Install our mock GL context so that it gets served by SharedGpuContext.
+    auto factory = [](FakeGLES2Interface* gl, bool* gpu_compositing_disabled)
+        -> std::unique_ptr<WebGraphicsContext3DProvider> {
+      *gpu_compositing_disabled = false;
+      // Unretained is safe since TearDown() cleans up the SharedGpuContext.
+      return std::make_unique<FakeWebGraphicsContext3DProvider>(gl);
+    };
+    SharedGpuContext::SetContextProviderFactoryForTesting(
+        WTF::BindRepeating(factory, WTF::Unretained(&gl_)));
+    context_provider_wrapper_ = SharedGpuContext::ContextProviderWrapper();
+  }
+
+  void TearDown() override { SharedGpuContext::ResetForTesting(); }
+
+ protected:
+  FakeGLES2Interface gl_;
+  base::WeakPtr<WebGraphicsContext3DProviderWrapper> context_provider_wrapper_;
+};
+
+TEST_F(CanvasResourceProviderTest,
+       CanvasResourceProviderTextureGpuMemoryBuffer) {
+  const IntSize kSize(10, 10);
+  const CanvasColorParams kColorParams(kSRGBCanvasColorSpace,
+                                       kRGBA8CanvasPixelFormat, kNonOpaque);
+
+  // Add the deduced gfx::BufferFormat if it's not supported.
+  auto* context_provider = context_provider_wrapper_->ContextProvider();
+  const gfx::BufferFormat buffer_format = kColorParams.GetBufferFormat();
+  if (!context_provider->GetCapabilities().gpu_memory_buffer_formats.Has(
+          buffer_format)) {
+    auto capabilities = context_provider->GetCapabilities();
+    capabilities.gpu_memory_buffer_formats.Add(buffer_format);
+
+    static_cast<FakeWebGraphicsContext3DProvider*>(context_provider)
+        ->SetCapabilities(capabilities);
+  }
+
+  auto provider = CanvasResourceProvider::Create(
+      kSize, CanvasResourceProvider::kAcceleratedCompositedResourceUsage,
+      context_provider_wrapper_, 0 /* msaa_sample_count */, kColorParams,
+      CanvasResourceProvider::kAllowImageChromiumPresentationMode,
+      nullptr /* resource_dispatcher */, true /* is_origin_top_left */);
+
+  EXPECT_EQ(provider->Size(), kSize);
+  EXPECT_TRUE(provider->IsValid());
+  EXPECT_TRUE(provider->IsAccelerated());
+  EXPECT_TRUE(provider->SupportsDirectCompositing());
+  EXPECT_TRUE(provider->SupportsSingleBuffering());
+  EXPECT_EQ(provider->ColorParams().ColorSpace(), kColorParams.ColorSpace());
+  EXPECT_EQ(provider->ColorParams().PixelFormat(), kColorParams.PixelFormat());
+  EXPECT_EQ(provider->ColorParams().GetOpacityMode(),
+            kColorParams.GetOpacityMode());
+
+  EXPECT_FALSE(provider->IsSingleBuffered());
+  provider->TryEnableSingleBuffering();
+  EXPECT_TRUE(provider->IsSingleBuffered());
+}
+
+TEST_F(CanvasResourceProviderTest, CanvasResourceProviderTexture) {
+  const IntSize kSize(10, 10);
+  const CanvasColorParams kColorParams(kSRGBCanvasColorSpace,
+                                       kRGBA8CanvasPixelFormat, kNonOpaque);
+
+  auto provider = CanvasResourceProvider::Create(
+      kSize, CanvasResourceProvider::kAcceleratedResourceUsage,
+      context_provider_wrapper_, 0 /* msaa_sample_count */, kColorParams,
+      CanvasResourceProvider::kAllowImageChromiumPresentationMode,
+      nullptr /* resource_dispatcher */, true /* is_origin_top_left */);
+
+  EXPECT_EQ(provider->Size(), kSize);
+  EXPECT_TRUE(provider->IsValid());
+  EXPECT_TRUE(provider->IsAccelerated());
+  EXPECT_TRUE(provider->SupportsDirectCompositing());
+  EXPECT_FALSE(provider->SupportsSingleBuffering());
+  EXPECT_EQ(provider->ColorParams().ColorSpace(), kColorParams.ColorSpace());
+  EXPECT_EQ(provider->ColorParams().PixelFormat(), kColorParams.PixelFormat());
+  EXPECT_EQ(provider->ColorParams().GetOpacityMode(),
+            kColorParams.GetOpacityMode());
+
+  EXPECT_FALSE(provider->IsSingleBuffered());
+}
+
+TEST_F(CanvasResourceProviderTest,
+       CanvasResourceProviderBitmapGpuMemoryBuffer) {
+  const IntSize kSize(10, 10);
+  const CanvasColorParams kColorParams(kSRGBCanvasColorSpace,
+                                       kRGBA8CanvasPixelFormat, kNonOpaque);
+
+  auto provider = CanvasResourceProvider::Create(
+      kSize, CanvasResourceProvider::kSoftwareCompositedResourceUsage,
+      context_provider_wrapper_, 0 /* msaa_sample_count */, kColorParams,
+      CanvasResourceProvider::kAllowImageChromiumPresentationMode,
+      nullptr /* resource_dispatcher */, true /* is_origin_top_left */);
+
+  EXPECT_EQ(provider->Size(), kSize);
+  EXPECT_TRUE(provider->IsValid());
+  EXPECT_FALSE(provider->IsAccelerated());
+  EXPECT_FALSE(provider->SupportsDirectCompositing());
+  EXPECT_FALSE(provider->SupportsSingleBuffering());
+  EXPECT_EQ(provider->ColorParams().ColorSpace(), kColorParams.ColorSpace());
+  EXPECT_EQ(provider->ColorParams().PixelFormat(), kColorParams.PixelFormat());
+  EXPECT_EQ(provider->ColorParams().GetOpacityMode(),
+            kColorParams.GetOpacityMode());
+
+  EXPECT_FALSE(provider->IsSingleBuffered());
+}
+
+TEST_F(CanvasResourceProviderTest, CanvasResourceProviderBitmap) {
+  const IntSize kSize(10, 10);
+  const CanvasColorParams kColorParams(kSRGBCanvasColorSpace,
+                                       kRGBA8CanvasPixelFormat, kNonOpaque);
+
+  auto provider = CanvasResourceProvider::Create(
+      kSize, CanvasResourceProvider::kSoftwareResourceUsage,
+      context_provider_wrapper_, 0 /* msaa_sample_count */, kColorParams,
+      CanvasResourceProvider::kAllowImageChromiumPresentationMode,
+      nullptr /* resource_dispatcher */, true /* is_origin_top_left */);
+
+  EXPECT_EQ(provider->Size(), kSize);
+  EXPECT_TRUE(provider->IsValid());
+  EXPECT_FALSE(provider->IsAccelerated());
+  EXPECT_FALSE(provider->SupportsDirectCompositing());
+  EXPECT_FALSE(provider->SupportsSingleBuffering());
+  EXPECT_EQ(provider->ColorParams().ColorSpace(), kColorParams.ColorSpace());
+  EXPECT_EQ(provider->ColorParams().PixelFormat(), kColorParams.PixelFormat());
+  EXPECT_EQ(provider->ColorParams().GetOpacityMode(),
+            kColorParams.GetOpacityMode());
+
+  EXPECT_FALSE(provider->IsSingleBuffered());
+}
+
+TEST_F(CanvasResourceProviderTest, CanvasResourceProviderSharedBitmap) {
+  const IntSize kSize(10, 10);
+  const CanvasColorParams kColorParams(kSRGBCanvasColorSpace,
+                                       kRGBA8CanvasPixelFormat, kNonOpaque);
+
+  MockCanvasResourceDispatcherClient client;
+  CanvasResourceDispatcher resource_dispatcher(
+      &client, 1 /* client_id */, 1 /* sink_id */,
+      1 /* placeholder_canvas_id */, kSize);
+
+  auto provider = CanvasResourceProvider::Create(
+      kSize, CanvasResourceProvider::kSoftwareCompositedResourceUsage,
+      context_provider_wrapper_, 0 /* msaa_sample_count */, kColorParams,
+      CanvasResourceProvider::kDefaultPresentationMode,
+      resource_dispatcher.GetWeakPtr(), true /* is_origin_top_left */);
+
+  EXPECT_EQ(provider->Size(), kSize);
+  EXPECT_TRUE(provider->IsValid());
+  EXPECT_FALSE(provider->IsAccelerated());
+  EXPECT_TRUE(provider->SupportsDirectCompositing());
+  EXPECT_TRUE(provider->SupportsSingleBuffering());
+  EXPECT_EQ(provider->ColorParams().ColorSpace(), kColorParams.ColorSpace());
+  EXPECT_EQ(provider->ColorParams().PixelFormat(), kColorParams.PixelFormat());
+  EXPECT_EQ(provider->ColorParams().GetOpacityMode(),
+            kColorParams.GetOpacityMode());
+
+  EXPECT_FALSE(provider->IsSingleBuffered());
+  provider->TryEnableSingleBuffering();
+  EXPECT_TRUE(provider->IsSingleBuffered());
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/graphics/test/fake_web_graphics_context_3d_provider.h

@@ -38,6 +38,7 @@ class FakeWebGraphicsContext3DProvider : public WebGraphicsContext3DProvider {
   const gpu::Capabilities& GetCapabilities() const override {
     return capabilities_;
   }
+  void SetCapabilities(const gpu::Capabilities& c) { capabilities_ = c; }
 
   const gpu::GpuFeatureInfo& GetGpuFeatureInfo() const override {
     return gpu_feature_info_;