Remove circuitous color parameter plumbing

Move methods for getting and setting color space and pixel format
from a string to CanvasColorParams.

CanvasRenderingContext has ColorSpaceAsString and PixelFormatAsString
method, which are redundant because it also has a method to get the
CanvasColorParams, from which these can be queried.

CanvasRenderingContext also has logic to handle situations where
the color space and pixel format are changed from what was specified.
This never happens, so remove it.

Also remove a number of redundant ColorSpace and PixelFormat accessors.

This will simplify adding these parameters to WebGLContextAttributes,
which was accidentally forgotten.

Bug: 1164230
Change-Id: I0471939c1f98b0c78f7a5dbbd3fb61940b9d7a64
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2617110Reviewed-by: Yi Xu <yiyix@chromium.org>
Reviewed-by: Fernando Serboncini <fserb@chromium.org>
Commit-Queue: Yi Xu <yiyix@chromium.org>
Cr-Commit-Position: refs/heads/master@{#842839}

third_party/blink/renderer/core/html/canvas/canvas_rendering_context.cc

@@ -40,50 +40,8 @@ CanvasRenderingContext::CanvasRenderingContext(
     CanvasRenderingContextHost* host,
     const CanvasContextCreationAttributesCore& attrs)
     : host_(host),
-      color_params_(CanvasColorSpace::kSRGB,
-                    CanvasPixelFormat::kUint8,
-                    kNonOpaque),
-      creation_attributes_(attrs) {
-  if (creation_attributes_.pixel_format == kF16CanvasPixelFormatName)
-    color_params_.SetCanvasPixelFormat(CanvasPixelFormat::kF16);
-
-  if (creation_attributes_.color_space == kRec2020CanvasColorSpaceName)
-    color_params_.SetCanvasColorSpace(CanvasColorSpace::kRec2020);
-  else if (creation_attributes_.color_space == kP3CanvasColorSpaceName)
-    color_params_.SetCanvasColorSpace(CanvasColorSpace::kP3);
-
-  if (!creation_attributes_.alpha)
-    color_params_.SetOpacityMode(kOpaque);
-
-  // Make creation_attributes_ reflect the effective color_space and
-  // pixel_format rather than the requested one.
-  creation_attributes_.color_space = ColorSpaceAsString();
-  creation_attributes_.pixel_format = PixelFormatAsString();
-}
-
-WTF::String CanvasRenderingContext::ColorSpaceAsString() const {
-  switch (color_params_.ColorSpace()) {
-    case CanvasColorSpace::kSRGB:
-      return kSRGBCanvasColorSpaceName;
-    case CanvasColorSpace::kRec2020:
-      return kRec2020CanvasColorSpaceName;
-    case CanvasColorSpace::kP3:
-      return kP3CanvasColorSpaceName;
-  };
-  CHECK(false);
-  return "";
-}
-
-WTF::String CanvasRenderingContext::PixelFormatAsString() const {
-  switch (color_params_.PixelFormat()) {
-    case CanvasPixelFormat::kF16:
-      return kF16CanvasPixelFormatName;
-    case CanvasPixelFormat::kUint8:
-      return kUint8CanvasPixelFormatName;
-  };
-  CHECK(false);
-  return "";
-}
+      color_params_(attrs.color_space, attrs.pixel_format, attrs.alpha),
+      creation_attributes_(attrs) {}
 
 void CanvasRenderingContext::Dispose() {
   StopListeningForDidProcessTask();

third_party/blink/renderer/core/html/canvas/canvas_rendering_context.h

@@ -90,9 +90,6 @@ class CORE_EXPORT CanvasRenderingContext : public ScriptWrappable,
 
   CanvasRenderingContextHost* Host() const { return host_; }
 
-  WTF::String ColorSpaceAsString() const;
-  WTF::String PixelFormatAsString() const;
-
   const CanvasColorParams& CanvasRenderingContextColorParams() const {
     return color_params_;
   }

third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.cc

@@ -1908,12 +1908,10 @@ void BaseRenderingContext2D::putImageData(ImageData* data,
           ? CanvasPixelFormat::kF16
           : CanvasPixelFormat::kUint8,
       kNonOpaque);
-  CanvasColorParams context_color_params = CanvasColorParams(
-      GetCanvas2DColorParams().ColorSpace(), PixelFormat(), kNonOpaque);
-
-  if (data_color_params.ColorSpace() != context_color_params.ColorSpace() ||
-      data_color_params.PixelFormat() != context_color_params.PixelFormat() ||
-      PixelFormat() == CanvasPixelFormat::kF16) {
+  if (data_color_params.ColorSpace() != GetCanvas2DColorParams().ColorSpace() ||
+      data_color_params.PixelFormat() !=
+          GetCanvas2DColorParams().PixelFormat() ||
+      GetCanvas2DColorParams().PixelFormat() == CanvasPixelFormat::kF16) {
     SkImageInfo converted_info = data_pixmap.info();
     converted_info =
         converted_info.makeColorType(GetCanvas2DColorParams().GetSkColorType());

third_party/blink/renderer/modules/canvas/canvas2d/base_rendering_context_2d.h

@@ -262,13 +262,6 @@ class MODULES_EXPORT BaseRenderingContext2D : public GarbageCollectedMixin,
 
   virtual void WillDrawImage(CanvasImageSource*) const {}
 
-  virtual String ColorSpaceAsString() const {
-    return kSRGBCanvasColorSpaceName;
-  }
-  virtual CanvasPixelFormat PixelFormat() const {
-    return CanvasPixelFormat::kUint8;
-  }
-
   void RestoreMatrixClipStack(cc::PaintCanvas*) const;
 
   String textAlign() const;

third_party/blink/renderer/modules/canvas/canvas2d/canvas_rendering_context_2d.cc

@@ -307,10 +307,6 @@ void CanvasRenderingContext2D::WillDrawImage(CanvasImageSource* source) const {
   canvas()->WillDrawImageTo2DContext(source);
 }
 
-String CanvasRenderingContext2D::ColorSpaceAsString() const {
-  return CanvasRenderingContext::ColorSpaceAsString();
-}
-
 CanvasColorParams CanvasRenderingContext2D::GetCanvas2DColorParams() const {
   return CanvasRenderingContext::CanvasRenderingContextColorParams();
 }
@@ -330,10 +326,6 @@ void CanvasRenderingContext2D::WillOverwriteCanvas() {
     canvas()->GetCanvas2DLayerBridge()->WillOverwriteCanvas();
 }
 
-CanvasPixelFormat CanvasRenderingContext2D::PixelFormat() const {
-  return GetCanvas2DColorParams().PixelFormat();
-}
-
 void CanvasRenderingContext2D::Reset() {
   // This is a multiple inheritance bootstrap
   BaseRenderingContext2D::reset();
@@ -1134,8 +1126,8 @@ CanvasRenderingContext2D::getContextAttributes() const {
       CanvasRenderingContext2DSettings::Create();
   settings->setAlpha(CreationAttributes().alpha);
   if (RuntimeEnabledFeatures::CanvasColorManagementEnabled()) {
-    settings->setColorSpace(ColorSpaceAsString());
-    settings->setPixelFormat(PixelFormatAsString());
+    settings->setColorSpace(GetCanvas2DColorParams().GetColorSpaceAsString());
+    settings->setPixelFormat(GetCanvas2DColorParams().GetPixelFormatAsString());
   }
   settings->setDesynchronized(Host()->LowLatencyEnabled());
   if (RuntimeEnabledFeatures::NewCanvas2DAPIEnabled())

third_party/blink/renderer/modules/canvas/canvas2d/canvas_rendering_context_2d.h

@@ -271,9 +271,6 @@ class MODULES_EXPORT CanvasRenderingContext2D final
     return CanvasRenderingContext::kContext2D;
   }
 
-  String ColorSpaceAsString() const override;
-  CanvasPixelFormat PixelFormat() const override;
-
   bool IsRenderingContext2D() const override { return true; }
   bool IsComposited() const override;
   bool IsAccelerated() const override;

third_party/blink/renderer/modules/canvas/offscreencanvas2d/offscreen_canvas_rendering_context_2d.cc

@@ -316,14 +316,6 @@ bool OffscreenCanvasRenderingContext2D::IsPaintable() const {
   return Host()->ResourceProvider();
 }
 
-String OffscreenCanvasRenderingContext2D::ColorSpaceAsString() const {
-  return CanvasRenderingContext::ColorSpaceAsString();
-}
-
-CanvasPixelFormat OffscreenCanvasRenderingContext2D::PixelFormat() const {
-  return GetCanvas2DColorParams().PixelFormat();
-}
-
 CanvasColorParams OffscreenCanvasRenderingContext2D::GetCanvas2DColorParams()
     const {
   return CanvasRenderingContext::CanvasRenderingContextColorParams();

third_party/blink/renderer/modules/canvas/offscreencanvas2d/offscreen_canvas_rendering_context_2d.h

@@ -171,8 +171,6 @@ class MODULES_EXPORT OffscreenCanvasRenderingContext2D final
 
   scoped_refptr<CanvasResource> ProduceCanvasResource();
 
-  String ColorSpaceAsString() const override;
-  CanvasPixelFormat PixelFormat() const override;
   SkIRect dirty_rect_for_commit_;
 
   bool is_valid_size_ = false;

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

@@ -82,12 +82,51 @@ CanvasColorParams::CanvasColorParams(CanvasColorSpace color_space,
       pixel_format_(pixel_format),
       opacity_mode_(opacity_mode) {}
 
+CanvasColorParams::CanvasColorParams(const WTF::String& color_space,
+                                     const WTF::String& pixel_format,
+                                     bool has_alpha) {
+  if (color_space == kRec2020CanvasColorSpaceName)
+    color_space_ = CanvasColorSpace::kRec2020;
+  else if (color_space == kP3CanvasColorSpaceName)
+    color_space_ = CanvasColorSpace::kP3;
+
+  if (pixel_format == kF16CanvasPixelFormatName)
+    pixel_format_ = CanvasPixelFormat::kF16;
+
+  if (!has_alpha)
+    opacity_mode_ = kOpaque;
+}
+
 CanvasResourceParams CanvasColorParams::GetAsResourceParams() const {
   SkAlphaType alpha_type =
       opacity_mode_ == kOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
   return CanvasResourceParams(color_space_, GetSkColorType(), alpha_type);
 }
 
+const char* CanvasColorParams::GetColorSpaceAsString() const {
+  switch (color_space_) {
+    case CanvasColorSpace::kSRGB:
+      return kSRGBCanvasColorSpaceName;
+    case CanvasColorSpace::kRec2020:
+      return kRec2020CanvasColorSpaceName;
+    case CanvasColorSpace::kP3:
+      return kP3CanvasColorSpaceName;
+  };
+  CHECK(false);
+  return "";
+}
+
+const char* CanvasColorParams::GetPixelFormatAsString() const {
+  switch (pixel_format_) {
+    case CanvasPixelFormat::kF16:
+      return kF16CanvasPixelFormatName;
+    case CanvasPixelFormat::kUint8:
+      return kUint8CanvasPixelFormatName;
+  };
+  CHECK(false);
+  return "";
+}
+
 SkColorType CanvasColorParams::GetSkColorType() const {
   switch (pixel_format_) {
     case CanvasPixelFormat::kF16:

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

@@ -59,14 +59,16 @@ class PLATFORM_EXPORT CanvasColorParams {
   // The default constructor will create an output-blended 8-bit surface.
   CanvasColorParams();
   CanvasColorParams(CanvasColorSpace, CanvasPixelFormat, OpacityMode);
+  CanvasColorParams(const WTF::String& color_space,
+                    const WTF::String& pixel_format,
+                    bool has_alpha);
 
   CanvasColorSpace ColorSpace() const { return color_space_; }
   CanvasPixelFormat PixelFormat() const { return pixel_format_; }
   OpacityMode GetOpacityMode() const { return opacity_mode_; }
 
-  void SetCanvasColorSpace(CanvasColorSpace c) { color_space_ = c; }
-  void SetCanvasPixelFormat(CanvasPixelFormat f) { pixel_format_ = f; }
-  void SetOpacityMode(OpacityMode m) { opacity_mode_ = m; }
+  const char* GetColorSpaceAsString() const;
+  const char* GetPixelFormatAsString() const;
 
   CanvasResourceParams GetAsResourceParams() const;