Move CanvasColorParams out of public

This reverts this change:
https://chromium-review.googlesource.com/c/chromium/src/+/1323715

And changes the WebGraphicsContext3dProvider implementation to not
depend on Blink internals by using Skia types.

Bug: 902022
Change-Id: I1fbe7a261095f4b30f1365e99005d332d66b7df8
Reviewed-on: https://chromium-review.googlesource.com/c/1323616Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Daniel Bratell <bratell@opera.com>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: enne <enne@chromium.org>
Cr-Commit-Position: refs/heads/master@{#608907}

content/renderer/webgraphicscontext3d_provider_impl.cc

@@ -77,12 +77,10 @@ void WebGraphicsContext3DProviderImpl::OnContextLost() {
 }
 
 cc::ImageDecodeCache* WebGraphicsContext3DProviderImpl::ImageDecodeCache(
-    blink::CanvasColorSpace color_space,
-    blink::CanvasPixelFormat pixel_format) {
-  SkColorType color_type = blink::PixelFormatToSkColorType(pixel_format);
-
+    SkColorType color_type,
+    sk_sp<SkColorSpace> color_space) {
   DCHECK(GetGrContext()->colorTypeSupportedAsImage(color_type));
-  auto key = std::make_pair(color_space, pixel_format);
+  auto key = std::make_pair(color_type, color_space->hash());
   auto cache_iterator = image_decode_cache_map_.find(key);
   if (cache_iterator != image_decode_cache_map_.end())
     return cache_iterator->second.get();
@@ -100,8 +98,7 @@ cc::ImageDecodeCache* WebGraphicsContext3DProviderImpl::ImageDecodeCache(
       std::make_unique<cc::GpuImageDecodeCache>(
           provider_.get(), use_transfer_cache, color_type, kMaxWorkingSetBytes,
           provider_->ContextCapabilities().max_texture_size,
-          cc::PaintImage::kDefaultGeneratorClientId,
-          blink::CanvasColorSpaceToSkColorSpace(color_space)));
+          cc::PaintImage::kDefaultGeneratorClientId, color_space));
   DCHECK(insertion_result.second);
   cache_iterator = insertion_result.first;
   return cache_iterator->second.get();

content/renderer/webgraphicscontext3d_provider_impl.h

@@ -52,8 +52,8 @@ class CONTENT_EXPORT WebGraphicsContext3DProviderImpl
   void SetErrorMessageCallback(
       base::RepeatingCallback<void(const char*, int32_t)>) override;
   cc::ImageDecodeCache* ImageDecodeCache(
-      blink::CanvasColorSpace color_space,
-      blink::CanvasPixelFormat pixel_format) override;
+      SkColorType color_type,
+      sk_sp<SkColorSpace> color_space) override;
 
   ws::ContextProviderCommandBuffer* context_provider() const {
     return provider_.get();
@@ -66,7 +66,7 @@ class CONTENT_EXPORT WebGraphicsContext3DProviderImpl
   scoped_refptr<ws::ContextProviderCommandBuffer> provider_;
   std::unique_ptr<viz::GLHelper> gl_helper_;
   base::RepeatingClosure context_lost_callback_;
-  base::flat_map<std::pair<blink::CanvasColorSpace, blink::CanvasPixelFormat>,
+  base::flat_map<std::pair<SkColorType, uint64_t>,
                  std::unique_ptr<cc::ImageDecodeCache>>
       image_decode_cache_map_;
 

third_party/blink/public/platform/web_graphics_context_3d_provider.h

@@ -33,7 +33,6 @@
 
 #include <cstdint>
 #include "base/callback_forward.h"
-#include "base/logging.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 
 class GrContext;
@@ -61,53 +60,6 @@ class GLHelper;
 
 namespace blink {
 
-enum CanvasColorSpace {
-  kSRGBCanvasColorSpace,
-  kLinearRGBCanvasColorSpace,
-  kRec2020CanvasColorSpace,
-  kP3CanvasColorSpace,
-  kMaxCanvasColorSpace = kP3CanvasColorSpace
-};
-
-enum CanvasPixelFormat {
-  kRGBA8CanvasPixelFormat,
-  kF16CanvasPixelFormat,
-  kMaxCanvasPixelFormat = kF16CanvasPixelFormat
-};
-
-inline SkColorType PixelFormatToSkColorType(CanvasPixelFormat pixel_format) {
-  switch (pixel_format) {
-    case kF16CanvasPixelFormat:
-      return kRGBA_F16_SkColorType;
-    case kRGBA8CanvasPixelFormat:
-      return kN32_SkColorType;
-  }
-  NOTREACHED();
-  return kN32_SkColorType;
-}
-
-inline sk_sp<SkColorSpace> CanvasColorSpaceToSkColorSpace(
-    CanvasColorSpace color_space) {
-  SkColorSpace::Gamut gamut = SkColorSpace::kSRGB_Gamut;
-  SkColorSpace::RenderTargetGamma gamma = SkColorSpace::kSRGB_RenderTargetGamma;
-  switch (color_space) {
-    case kSRGBCanvasColorSpace:
-      break;
-    case kLinearRGBCanvasColorSpace:
-      gamma = SkColorSpace::kLinear_RenderTargetGamma;
-      break;
-    case kRec2020CanvasColorSpace:
-      gamut = SkColorSpace::kRec2020_Gamut;
-      gamma = SkColorSpace::kLinear_RenderTargetGamma;
-      break;
-    case kP3CanvasColorSpace:
-      gamut = SkColorSpace::kDCIP3_D65_Gamut;
-      gamma = SkColorSpace::kLinear_RenderTargetGamma;
-      break;
-  }
-  return SkColorSpace::MakeRGB(gamma, gamut);
-}
-
 class WebGraphicsContext3DProvider {
  public:
   virtual ~WebGraphicsContext3DProvider() = default;
@@ -125,11 +77,11 @@ class WebGraphicsContext3DProvider {
   virtual void SetLostContextCallback(base::RepeatingClosure) = 0;
   virtual void SetErrorMessageCallback(
       base::RepeatingCallback<void(const char* msg, int32_t id)>) = 0;
-  // Return a static software image decode cache that matches this color
-  // space and pixel format.
+  // Return a static software image decode cache for a given color type and
+  // space.
   virtual cc::ImageDecodeCache* ImageDecodeCache(
-      CanvasColorSpace color_space,
-      CanvasPixelFormat pixel_format) = 0;
+      SkColorType color_type,
+      sk_sp<SkColorSpace> color_space) = 0;
 };
 
 }  // namespace blink

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

@@ -124,6 +124,19 @@ SkColorType CanvasColorParams::GetSkColorType() const {
   return PixelFormatToSkColorType(pixel_format_);
 }
 
+// static
+SkColorType CanvasColorParams::PixelFormatToSkColorType(
+    CanvasPixelFormat pixel_format) {
+  switch (pixel_format) {
+    case kF16CanvasPixelFormat:
+      return kRGBA_F16_SkColorType;
+    case kRGBA8CanvasPixelFormat:
+      return kN32_SkColorType;
+  }
+  NOTREACHED();
+  return kN32_SkColorType;
+}
+
 SkAlphaType CanvasColorParams::GetSkAlphaType() const {
   if (opacity_mode_ == kOpaque)
     return kOpaque_SkAlphaType;
@@ -171,6 +184,28 @@ sk_sp<SkColorSpace> CanvasColorParams::GetSkColorSpace() const {
   return CanvasColorSpaceToSkColorSpace(color_space_);
 }
 
+sk_sp<SkColorSpace> CanvasColorParams::CanvasColorSpaceToSkColorSpace(
+    CanvasColorSpace color_space) {
+  SkColorSpace::Gamut gamut = SkColorSpace::kSRGB_Gamut;
+  SkColorSpace::RenderTargetGamma gamma = SkColorSpace::kSRGB_RenderTargetGamma;
+  switch (color_space) {
+    case kSRGBCanvasColorSpace:
+      break;
+    case kLinearRGBCanvasColorSpace:
+      gamma = SkColorSpace::kLinear_RenderTargetGamma;
+      break;
+    case kRec2020CanvasColorSpace:
+      gamut = SkColorSpace::kRec2020_Gamut;
+      gamma = SkColorSpace::kLinear_RenderTargetGamma;
+      break;
+    case kP3CanvasColorSpace:
+      gamut = SkColorSpace::kDCIP3_D65_Gamut;
+      gamma = SkColorSpace::kLinear_RenderTargetGamma;
+      break;
+  }
+  return SkColorSpace::MakeRGB(gamma, gamut);
+}
+
 gfx::BufferFormat CanvasColorParams::GetBufferFormat() const {
   static_assert(kN32_SkColorType == kRGBA_8888_SkColorType ||
                     kN32_SkColorType == kBGRA_8888_SkColorType,

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

@@ -6,7 +6,6 @@
 #define THIRD_PARTY_BLINK_RENDERER_PLATFORM_GRAPHICS_CANVAS_COLOR_PARAMS_H_
 
 #include "components/viz/common/resources/resource_format.h"
-#include "third_party/blink/public/platform/web_graphics_context_3d_provider.h"
 #include "third_party/blink/renderer/platform/graphics/graphics_types.h"
 #include "third_party/blink/renderer/platform/platform_export.h"
 #include "third_party/skia/include/core/SkColorSpace.h"
@@ -25,6 +24,20 @@ class ColorSpace;
 
 namespace blink {
 
+enum CanvasColorSpace {
+  kSRGBCanvasColorSpace,
+  kLinearRGBCanvasColorSpace,
+  kRec2020CanvasColorSpace,
+  kP3CanvasColorSpace,
+  kMaxCanvasColorSpace = kP3CanvasColorSpace
+};
+
+enum CanvasPixelFormat {
+  kRGBA8CanvasPixelFormat,
+  kF16CanvasPixelFormat,
+  kMaxCanvasPixelFormat = kF16CanvasPixelFormat
+};
+
 class PLATFORM_EXPORT CanvasColorParams {
  public:
   // The default constructor will create an output-blended 8-bit surface.
@@ -61,9 +74,7 @@ class PLATFORM_EXPORT CanvasColorParams {
 
   // The pixel format to use for allocating SkSurfaces.
   SkColorType GetSkColorType() const;
-  static SkColorType PixelFormatToSkColorType(CanvasPixelFormat pixel_format) {
-    return ::blink::PixelFormatToSkColorType(pixel_format);
-  }
+  static SkColorType PixelFormatToSkColorType(CanvasPixelFormat pixel_format);
   uint8_t BytesPerPixel() const;
 
   // The color space in which pixels read from the canvas via a shader will be
@@ -75,9 +86,7 @@ class PLATFORM_EXPORT CanvasColorParams {
   gfx::ColorSpace GetStorageGfxColorSpace() const;
   sk_sp<SkColorSpace> GetSkColorSpace() const;
   static sk_sp<SkColorSpace> CanvasColorSpaceToSkColorSpace(
-      CanvasColorSpace color_space) {
-    return ::blink::CanvasColorSpaceToSkColorSpace(color_space);
-  }
+      CanvasColorSpace color_space);
   SkAlphaType GetSkAlphaType() const;
   const SkSurfaceProps* GetSkSurfaceProps() const;
 

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

@@ -751,7 +751,8 @@ cc::ImageDecodeCache* CanvasResourceProvider::ImageDecodeCacheRGBA8() {
 
   if (IsAccelerated() && context_provider_wrapper_) {
     return context_provider_wrapper_->ContextProvider()->ImageDecodeCache(
-        color_space, kRGBA8CanvasPixelFormat);
+        kN32_SkColorType,
+        blink::CanvasColorParams::CanvasColorSpaceToSkColorSpace(color_space));
   }
 
   return Image::SharedCCDecodeCache(color_space, kRGBA8CanvasPixelFormat);
@@ -765,7 +766,8 @@ cc::ImageDecodeCache* CanvasResourceProvider::ImageDecodeCacheF16() {
 
   if (IsAccelerated() && context_provider_wrapper_) {
     return context_provider_wrapper_->ContextProvider()->ImageDecodeCache(
-        color_space, kF16CanvasPixelFormat);
+        kRGBA_F16_SkColorType,
+        blink::CanvasColorParams::CanvasColorSpaceToSkColorSpace(color_space));
   }
   return Image::SharedCCDecodeCache(color_space, kF16CanvasPixelFormat);
 }

third_party/blink/renderer/platform/graphics/gpu/drawing_buffer_test_helpers.h

@@ -53,8 +53,9 @@ class WebGraphicsContext3DProviderForTests
   void SetLostContextCallback(base::Closure) override {}
   void SetErrorMessageCallback(
       base::RepeatingCallback<void(const char*, int32_t id)>) override {}
-  cc::ImageDecodeCache* ImageDecodeCache(CanvasColorSpace,
-                                         CanvasPixelFormat) override {
+  cc::ImageDecodeCache* ImageDecodeCache(
+      SkColorType color_type,
+      sk_sp<SkColorSpace> color_space) override {
     return &image_decode_cache_;
   }
 

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

@@ -53,8 +53,9 @@ class FakeWebGraphicsContext3DProvider : public WebGraphicsContext3DProvider {
   void SetLostContextCallback(base::Closure) override {}
   void SetErrorMessageCallback(
       base::RepeatingCallback<void(const char*, int32_t id)>) override {}
-  cc::ImageDecodeCache* ImageDecodeCache(CanvasColorSpace,
-                                         CanvasPixelFormat) override {
+  cc::ImageDecodeCache* ImageDecodeCache(
+      SkColorType color_type,
+      sk_sp<SkColorSpace> color_space) override {
     return image_decode_cache_;
   }