Plumb CanvasColorParams to canvas image classes

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 Google Inc. 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 69 matching lines @@
 
   // The id of the texture bound to the CHROMIUM image.
   const GLuint texture_id_;
 };
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
 static sk_sp<SkSurface> CreateSkSurface(GrContext* gr,
                                         const IntSize& size,
                                         int msaa_sample_count,
                                         OpacityMode opacity_mode,
-                                        sk_sp<SkColorSpace> color_space,
-                                        SkColorType color_type,
+                                        const CanvasColorParams& color_params,
                                         bool* surface_is_accelerated) {
   if (gr)
     gr->resetContext();
 
   SkAlphaType alpha_type =
       (kOpaque == opacity_mode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-  SkImageInfo info = SkImageInfo::Make(size.Width(), size.Height(), color_type,
-                                       alpha_type, color_space);
+  SkImageInfo info = SkImageInfo::Make(
+      size.Width(), size.Height(), color_params.GetSkColorType(), alpha_type,
+      color_params.GetSkColorSpaceForSkSurfaces());
   SkSurfaceProps disable_lcd_props(0, kUnknown_SkPixelGeometry);
   sk_sp<SkSurface> surface;
 
   if (gr) {
     *surface_is_accelerated = true;
     surface = SkSurface::MakeRenderTarget(
         gr, SkBudgeted::kNo, info, msaa_sample_count,
         kOpaque == opacity_mode ? 0 : &disable_lcd_props);
   }
 
@@ skipping 12 matching lines @@
   }
   return surface;
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(
     std::unique_ptr<WebGraphicsContext3DProvider> context_provider,
     const IntSize& size,
     int msaa_sample_count,
     OpacityMode opacity_mode,
     AccelerationMode acceleration_mode,
-    const gfx::ColorSpace& color_space,
-    bool sk_surfaces_use_color_space,
-    SkColorType color_type)
+    const CanvasColorParams& color_params)
     : context_provider_(std::move(context_provider)),
       logger_(WTF::WrapUnique(new Logger)),
       weak_ptr_factory_(this),
       image_buffer_(0),
       msaa_sample_count_(msaa_sample_count),
       bytes_allocated_(0),
       have_recorded_draw_commands_(false),
       destruction_in_progress_(false),
       filter_quality_(kLow_SkFilterQuality),
       is_hidden_(false),
       is_deferral_enabled_(true),
       software_rendering_while_hidden_(false),
       last_image_id_(0),
       last_filter_(GL_LINEAR),
       acceleration_mode_(acceleration_mode),
       opacity_mode_(opacity_mode),
       size_(size),
-      color_space_(color_space),
-      sk_surfaces_use_color_space_(sk_surfaces_use_color_space),
-      color_type_(color_type) {
+      color_params_(color_params) {
   DCHECK(context_provider_);
   DCHECK(!context_provider_->IsSoftwareRendering());
-  DCHECK(color_space_.IsValid());
+  DCHECK(color_params_.GetGfxColorSpace().IsValid());
   // Used by browser tests to detect the use of a Canvas2DLayerBridge.
   TRACE_EVENT_INSTANT0("test_gpu", "Canvas2DLayerBridgeCreation",
                        TRACE_EVENT_SCOPE_GLOBAL);
   StartRecording();
 }
 
 Canvas2DLayerBridge::~Canvas2DLayerBridge() {
   DCHECK(destruction_in_progress_);
 #if USE_IOSURFACE_FOR_2D_CANVAS
   ClearCHROMIUMImageCache();
@@ skipping 111 matching lines @@
 
   info.image_info_ = image_info;
   bool is_overlay_candidate = true;
   bool secure_output_only = false;
   info.mailbox_ = mailbox;
 
   *out_mailbox =
       cc::TextureMailbox(mailbox, sync_token, texture_target, gfx::Size(size_),
                          is_overlay_candidate, secure_output_only);
   if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
-    out_mailbox->set_color_space(color_space_);
-    image_info->gpu_memory_buffer_->SetColorSpaceForScanout(color_space_);
+    gfx::ColorSpace color_space = color_params_.GetGfxColorSpace();
+    out_mailbox->set_color_space(color_space);
+    image_info->gpu_memory_buffer_->SetColorSpaceForScanout(color_space);
   }
 
   gl->BindTexture(GC3D_TEXTURE_RECTANGLE_ARB, 0);
 
   // Because we are changing the texture binding without going through skia,
   // we must dirty the context.
   gr_context->resetContext(kTextureBinding_GrGLBackendState);
 
   return true;
 }
@@ skipping 223 matching lines @@
                  &copy_paint);  // GPU readback
   hibernation_image_ = temp_hibernation_surface->makeImageSnapshot();
   ResetSurface();
   layer_->ClearTexture();
 #if USE_IOSURFACE_FOR_2D_CANVAS
   ClearCHROMIUMImageCache();
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
   logger_->DidStartHibernating();
 }
 
-sk_sp<SkColorSpace> Canvas2DLayerBridge::SkSurfaceColorSpace() const {
-  if (sk_surfaces_use_color_space_)
-    return color_space_.ToSkColorSpace();
-  return nullptr;
-}
-
 void Canvas2DLayerBridge::ReportSurfaceCreationFailure() {
   if (!surface_creation_failed_at_least_once_) {
     // Only count the failure once per instance so that the histogram may
     // reflect the proportion of Canvas2DLayerBridge instances with surface
     // allocation failures.
     CanvasMetrics::CountCanvasContextUsage(
         CanvasMetrics::kGPUAccelerated2DCanvasSurfaceCreationFailed);
     surface_creation_failed_at_least_once_ = true;
   }
 }
@@ skipping 10 matching lines @@
   bool want_acceleration = ShouldAccelerate(hint);
   if (CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU && IsHidden() &&
       want_acceleration) {
     want_acceleration = false;
     software_rendering_while_hidden_ = true;
   }
 
   bool surface_is_accelerated;
   surface_ = CreateSkSurface(
       want_acceleration ? context_provider_->GetGrContext() : nullptr, size_,
-      msaa_sample_count_, opacity_mode_, SkSurfaceColorSpace(), color_type_,
+      msaa_sample_count_, opacity_mode_, color_params_,
       &surface_is_accelerated);
   surface_paint_canvas_ =
       WTF::WrapUnique(new SkiaPaintCanvas(surface_->getCanvas()));
 
   if (surface_) {
     // Always save an initial frame, to support resetting the top level matrix
     // and clip.
     surface_paint_canvas_->save();
   } else {
     ReportSurfaceCreationFailure();
@@ skipping 199 matching lines @@
 
   if (have_recorded_draw_commands_ && GetOrCreateSurface()) {
     TRACE_EVENT0("cc", "Canvas2DLayerBridge::flushRecordingOnly");
 
     // For legacy canvases, transform all input colors and images to the target
     // space using a SkCreateColorSpaceXformCanvas. This ensures blending will
     // be done using target space pixel values.
     SkCanvas* canvas = GetOrCreateSurface()->getCanvas();
     std::unique_ptr<SkCanvas> color_transform_canvas;
     if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled() &&
-        !sk_surfaces_use_color_space_) {
-      color_transform_canvas =
-          SkCreateColorSpaceXformCanvas(canvas, color_space_.ToSkColorSpace());
+        color_params_.UsesOutputSpaceBlending()) {
+      color_transform_canvas = SkCreateColorSpaceXformCanvas(
+          canvas, color_params_.GetSkColorSpace());
       canvas = color_transform_canvas.get();
     }
 
     recorder_->finishRecordingAsPicture()->playback(canvas);
     if (is_deferral_enabled_)
       StartRecording();
     have_recorded_draw_commands_ = false;
   }
 }
 
@@ skipping 66 matching lines @@
   gpu::gles2::GLES2Interface* shared_gl = nullptr;
   layer_->ClearTexture();
   context_provider_ = WTF::WrapUnique(
       Platform::Current()->CreateSharedOffscreenGraphicsContext3DProvider());
   if (context_provider_)
     shared_gl = context_provider_->ContextGL();
 
   if (shared_gl && shared_gl->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* gr_ctx = context_provider_->GetGrContext();
     bool surface_is_accelerated;
-    sk_sp<SkSurface> surface(CreateSkSurface(
-        gr_ctx, size_, msaa_sample_count_, opacity_mode_, SkSurfaceColorSpace(),
-        color_type_, &surface_is_accelerated));
+    sk_sp<SkSurface> surface(CreateSkSurface(gr_ctx, size_, msaa_sample_count_,
+                                             opacity_mode_, color_params_,
+                                             &surface_is_accelerated));
     if (!surface_)
       ReportSurfaceCreationFailure();
 
     // The current paradigm does not support switching from accelerated to
     // non-accelerated, which would be tricky due to changes to the layer tree,
     // which can only happen at specific times during the document lifecycle.
     // Therefore, we can only accept the restored surface if it is accelerated.
     if (surface && surface_is_accelerated) {
       surface_ = std::move(surface);
       // FIXME: draw sad canvas picture into new buffer crbug.com/243842
@@ skipping 46 matching lines @@
   // Early exit if canvas was not drawn to since last prepareMailbox.
   GLenum filter = GetGLFilter();
   if (image->uniqueID() == last_image_id_ && filter == last_filter_)
     return false;
   last_image_id_ = image->uniqueID();
   last_filter_ = filter;
 
   if (!PrepareMailboxFromImage(std::move(image), out_mailbox))
     return false;
   out_mailbox->set_nearest_neighbor(GetGLFilter() == GL_NEAREST);
-  out_mailbox->set_color_space(color_space_);
+  out_mailbox->set_color_space(color_params_.GetGfxColorSpace());
 
   auto func =
       WTF::Bind(&Canvas2DLayerBridge::MailboxReleased,
                 weak_ptr_factory_.CreateWeakPtr(), out_mailbox->mailbox());
   *out_release_callback =
       cc::SingleReleaseCallback::Create(ConvertToBaseCallback(std::move(func)));
   return true;
 }
 
 void Canvas2DLayerBridge::MailboxReleased(const gpu::Mailbox& mailbox,
@@ skipping 171 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::ReportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernation_histogram,
                       ("Canvas.HibernationEvents", kHibernationEventCount));
   hibernation_histogram.Count(event);
 }
 
 }  // namespace blink