Replacing kSoftwareCompositedUsage from tests

This CL remove usages of :Create with the Software
Composited Usage, and one of them with Accelerated
Composited Usage.

This CL marks as deprecated kSoftwareCompositedUsage
as it is no longer used throughout the code base.


Bug: 1035589
Change-Id: Ic8648a57a473d5533e49508b286bc595db5356bc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2196958Reviewed-by: Aaron Krajeski <aaronhk@chromium.org>
Reviewed-by: Yi Xu <yiyix@chromium.org>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: Juanmi Huertas <juanmihd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#768828}

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

@@ -87,14 +87,17 @@ class CanvasResourceDispatcherTest
 
   void CreateCanvasResourceDispatcher() {
     dispatcher_ = std::make_unique<MockCanvasResourceDispatcher>();
-    resource_provider_ = CanvasResourceProvider::Create(
-        IntSize(kWidth, kHeight),
-        CanvasResourceProvider::ResourceUsage::kSoftwareCompositedResourceUsage,
-        nullptr,  // context_provider_wrapper
-        0,        // msaa_sample_count
-        kLow_SkFilterQuality, CanvasColorParams(),
-        CanvasResourceProvider::kDefaultPresentationMode,
-        dispatcher_->GetWeakPtr());
+    // TODO(crbug/1035589) Previously a call to the more generic function
+    // `CanvasResourceProvider::Create` was used but due to `presentationMode =
+    // kDefaultPresentationMode` created a sharedBitmap 100% of the time.
+    // Investigate study if the Bitmap fallback makes sense or not.
+    resource_provider_ = CanvasResourceProvider::CreateSharedBitmapProvider(
+        IntSize(kWidth, kHeight), nullptr /* context_provider_wrapper */,
+        kLow_SkFilterQuality, CanvasColorParams(), dispatcher_->GetWeakPtr());
+    if (!resource_provider_) {
+      resource_provider_ = CanvasResourceProvider::CreateBitmapProvider(
+          IntSize(kWidth, kHeight), kLow_SkFilterQuality, CanvasColorParams());
+    }
   }
 
   MockCanvasResourceDispatcher* Dispatcher() { return dispatcher_.get(); }

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

@@ -785,15 +785,10 @@ const Vector<CanvasResourceType>& GetResourceTypeFallbackList(
     case CanvasResourceProvider::ResourceUsage::kSoftwareResourceUsage:
     case CanvasResourceProvider::ResourceUsage::
         kSoftwareCompositedDirect2DResourceUsage:
-      NOTREACHED();
-      return kEmptyList;
     case CanvasResourceProvider::ResourceUsage::
         kSoftwareCompositedResourceUsage:
-      if (base::FeatureList::IsEnabled(blink::features::kDawn2dCanvas)) {
-        return kCompositedFallbackListWithDawn;
-      }
-      return kCompositedFallbackList;
-
+      NOTREACHED();
+      return kEmptyList;
     case CanvasResourceProvider::ResourceUsage::
         kAcceleratedCompositedResourceUsage:
       if (base::FeatureList::IsEnabled(blink::features::kDawn2dCanvas)) {
@@ -828,6 +823,7 @@ std::unique_ptr<CanvasResourceProvider> CanvasResourceProvider::Create(
   DCHECK(usage != ResourceUsage::kSoftwareResourceUsage);
   DCHECK(usage != ResourceUsage::kAcceleratedResourceUsage);
   DCHECK(usage != ResourceUsage::kSoftwareCompositedDirect2DResourceUsage);
+  DCHECK(usage != ResourceUsage::kSoftwareCompositedResourceUsage);
 
   std::unique_ptr<CanvasResourceProvider> provider;
 

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

@@ -62,9 +62,9 @@ class PLATFORM_EXPORT CanvasResourceProvider
   // TODO(juanmihd@ bug/1035589) ResourceUsage will be removed soon, try
   // avoiding using this.
   enum class ResourceUsage {
-    kSoftwareResourceUsage = 0,  // deprecated
-    kSoftwareCompositedResourceUsage = 1,
-    kAcceleratedResourceUsage = 2,  // deprecated
+    kSoftwareResourceUsage = 0,            // deprecated
+    kSoftwareCompositedResourceUsage = 1,  // deprecated
+    kAcceleratedResourceUsage = 2,         // deprecated
     kAcceleratedCompositedResourceUsage = 3,
     kAcceleratedDirect2DResourceUsage = 4,
     kAcceleratedDirect3DResourceUsage = 5,

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

@@ -135,13 +135,13 @@ TEST_F(CanvasResourceProviderTest, CanvasResourceProviderUnacceleratedOverlay) {
       CanvasColorSpace::kSRGB, CanvasColorParams::GetNativeCanvasPixelFormat(),
       kNonOpaque);
 
-  auto provider = CanvasResourceProvider::Create(
-      kSize,
-      CanvasResourceProvider::ResourceUsage::kSoftwareCompositedResourceUsage,
-      context_provider_wrapper_, 0 /* msaa_sample_count */,
-      kLow_SkFilterQuality, kColorParams,
-      CanvasResourceProvider::kAllowImageChromiumPresentationMode,
-      nullptr /* resource_dispatcher */, true /* is_origin_top_left */);
+  const uint32_t shared_image_usage_flags =
+      gpu::SHARED_IMAGE_USAGE_DISPLAY | gpu::SHARED_IMAGE_USAGE_SCANOUT;
+
+  auto provider = CanvasResourceProvider::CreateSharedImageProvider(
+      kSize, context_provider_wrapper_, kLow_SkFilterQuality, kColorParams,
+      true /* is_origin_top_left */, CanvasResourceProvider::RasterMode::kCPU,
+      shared_image_usage_flags);
 
   EXPECT_EQ(provider->Size(), kSize);
   EXPECT_TRUE(provider->IsValid());
@@ -320,13 +320,9 @@ TEST_F(CanvasResourceProviderTest, CanvasResourceProviderSharedBitmap) {
       &client, 1 /* client_id */, 1 /* sink_id */,
       1 /* placeholder_canvas_id */, kSize);
 
-  auto provider = CanvasResourceProvider::Create(
-      kSize,
-      CanvasResourceProvider::ResourceUsage::kSoftwareCompositedResourceUsage,
-      context_provider_wrapper_, 0 /* msaa_sample_count */,
-      kLow_SkFilterQuality, kColorParams,
-      CanvasResourceProvider::kDefaultPresentationMode,
-      resource_dispatcher.GetWeakPtr(), true /* is_origin_top_left */);
+  auto provider = CanvasResourceProvider::CreateSharedBitmapProvider(
+      kSize, context_provider_wrapper_, kLow_SkFilterQuality, kColorParams,
+      resource_dispatcher.GetWeakPtr());
 
   EXPECT_EQ(provider->Size(), kSize);
   EXPECT_TRUE(provider->IsValid());
@@ -527,7 +523,7 @@ TEST_F(CanvasResourceProviderTest, DimensionsExceedMaxTextureSize) {
         continue;
       case CanvasResourceProvider::ResourceUsage::
           kSoftwareCompositedResourceUsage:
-        FALLTHROUGH;
+        continue;
       case CanvasResourceProvider::ResourceUsage::
           kSoftwareCompositedDirect2DResourceUsage:
         FALLTHROUGH;

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

@@ -33,23 +33,33 @@ class FakeCanvasResourceHost : public CanvasResourceHost {
     if (ResourceProvider())
       return ResourceProvider();
 
-    CanvasResourceProvider::ResourceUsage usage =
-        hint == kPreferAcceleration ? CanvasResourceProvider::ResourceUsage::
-                                          kAcceleratedCompositedResourceUsage
-                                    : CanvasResourceProvider::ResourceUsage::
-                                          kSoftwareCompositedResourceUsage;
-
-    uint8_t presentation_mode =
-        CanvasResourceProvider::kDefaultPresentationMode;
-    if (RuntimeEnabledFeatures::Canvas2dImageChromiumEnabled()) {
-      presentation_mode |=
-          CanvasResourceProvider::kAllowImageChromiumPresentationMode;
+    std::unique_ptr<CanvasResourceProvider> provider;
+    if (hint == kPreferAcceleration ||
+        RuntimeEnabledFeatures::Canvas2dImageChromiumEnabled()) {
+      uint32_t shared_image_usage_flags =
+          gpu::SHARED_IMAGE_USAGE_DISPLAY | gpu::SHARED_IMAGE_USAGE_SCANOUT;
+      provider = CanvasResourceProvider::CreateSharedImageProvider(
+          size_, SharedGpuContext::ContextProviderWrapper(),
+          kMedium_SkFilterQuality, CanvasColorParams(),
+          false /*is_origin_top_left*/,
+          hint == kPreferAcceleration
+              ? CanvasResourceProvider::RasterMode::kGPU
+              : CanvasResourceProvider::RasterMode::kCPU,
+          shared_image_usage_flags);
+    }
+    if (!provider) {
+      provider = CanvasResourceProvider::CreateSharedBitmapProvider(
+          size_, SharedGpuContext::ContextProviderWrapper(),
+          kMedium_SkFilterQuality, CanvasColorParams(),
+          nullptr /* dispatcher_weakptr */);
     }
+    if (!provider) {
+      provider = CanvasResourceProvider::CreateBitmapProvider(
+          size_, kMedium_SkFilterQuality, CanvasColorParams());
+    }
+
+    ReplaceResourceProvider(std::move(provider));
 
-    ReplaceResourceProvider(CanvasResourceProvider::Create(
-        size_, usage, SharedGpuContext::ContextProviderWrapper(), 0,
-        kMedium_SkFilterQuality, CanvasColorParams(), presentation_mode,
-        nullptr));
     return ResourceProvider();
   }