Plumb CanvasColorParams to canvas image classes

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

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 874 matching lines @@
 }
 
 namespace {
 
 class UnacceleratedSurfaceFactory
     : public RecordingImageBufferFallbackSurfaceFactory {
  public:
   virtual std::unique_ptr<ImageBufferSurface> CreateSurface(
       const IntSize& size,
       OpacityMode opacity_mode,
-      sk_sp<SkColorSpace> color_space,
-      SkColorType color_type) {
+      const CanvasColorParams& color_params) {
     return WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-        size, opacity_mode, kInitializeImagePixels, color_space, color_type));
+        size, opacity_mode, kInitializeImagePixels, color_params));
   }
 
   virtual ~UnacceleratedSurfaceFactory() {}
 };
 
 }  // namespace
 
 bool HTMLCanvasElement::ShouldUseDisplayList() {
-  if (context_->ColorSpace() != kLegacyCanvasColorSpace)
+  // Rasterization of web contents will blend in the output space. Only embed
+  // the canvas as a display list if it intended to do output space blending as
+  // well.
+  if (!context_->color_params().UsesOutputSpaceBlending())
     return false;
 
   if (RuntimeEnabledFeatures::forceDisplayList2dCanvasEnabled())
     return true;
 
   if (!RuntimeEnabledFeatures::displayList2dCanvasEnabled())
     return false;
 
   return true;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateWebGLImageBufferSurface(OpacityMode opacity_mode) {
   DCHECK(Is3d());
   // If 3d, but the use of the canvas will be for non-accelerated content
   // then make a non-accelerated ImageBuffer. This means copying the internal
   // Image will require a pixel readback, but that is unavoidable in this case.
   auto surface = WTF::WrapUnique(new AcceleratedImageBufferSurface(
-      size(), opacity_mode, context_->SkSurfaceColorSpace(),
-      context_->ColorType()));
+      size(), opacity_mode, context_->color_params()));
   if (surface->IsValid())
     return std::move(surface);
   return nullptr;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateAcceleratedImageBufferSurface(OpacityMode opacity_mode,
                                                        int* msaa_sample_count) {
   if (GetDocument().GetSettings()) {
     *msaa_sample_count =
         GetDocument().GetSettings()->GetAccelerated2dCanvasMSAASampleCount();
   }
 
   // Avoid creating |contextProvider| until we're sure we want to try use it,
   // since it costs us GPU memory.
   std::unique_ptr<WebGraphicsContext3DProvider> context_provider(
       Platform::Current()->CreateSharedOffscreenGraphicsContext3DProvider());
   if (!context_provider) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kAccelerated2DCanvasGPUContextLost);
     return nullptr;
   }
 
   if (context_provider->IsSoftwareRendering())
     return nullptr;  // Don't use accelerated canvas with swiftshader.
 
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::WrapUnique(new Canvas2DImageBufferSurface(
           std::move(context_provider), size(), *msaa_sample_count, opacity_mode,
-          Canvas2DLayerBridge::kEnableAcceleration, context_->GfxColorSpace(),
-          context_->SkSurfacesUseColorSpace(), context_->ColorType()));
+          Canvas2DLayerBridge::kEnableAcceleration, context_->color_params()));
   if (!surface->IsValid()) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kGPUAccelerated2DCanvasImageBufferCreationFailed);
     return nullptr;
   }
 
   CanvasMetrics::CountCanvasContextUsage(
       CanvasMetrics::kGPUAccelerated2DCanvasImageBufferCreated);
   return surface;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::CreateUnacceleratedImageBufferSurface(
     OpacityMode opacity_mode) {
   if (ShouldUseDisplayList()) {
     auto surface = WTF::WrapUnique(new RecordingImageBufferSurface(
         size(), WTF::WrapUnique(new UnacceleratedSurfaceFactory), opacity_mode,
-        context_->SkSurfaceColorSpace(), context_->ColorType()));
+        context_->color_params()));
     if (surface->IsValid()) {
       CanvasMetrics::CountCanvasContextUsage(
           CanvasMetrics::kDisplayList2DCanvasImageBufferCreated);
       return std::move(surface);
     }
     // We fallback to a non-display-list surface without recording a metric
     // here.
   }
 
   auto surface_factory = WTF::MakeUnique<UnacceleratedSurfaceFactory>();
   auto surface = surface_factory->CreateSurface(size(), opacity_mode,
-                                                context_->SkSurfaceColorSpace(),
-                                                context_->ColorType());
+                                                context_->color_params());
   if (surface->IsValid()) {
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kUnaccelerated2DCanvasImageBufferCreated);
     return surface;
   }
 
   CanvasMetrics::CountCanvasContextUsage(
       CanvasMetrics::kUnaccelerated2DCanvasImageBufferCreationFailed);
   return nullptr;
 }
@@ skipping 480 matching lines @@
     // Creates a placeholder layer first before Surface is created.
     surface_layer_bridge_->CreateSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   SetNeedsCompositingUpdate();
 }
 
 }  // namespace blink