Use gfx::ColorSpace instead of SkColorSpace in Blink

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 109 matching lines @@
   }
   return surface;
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const IntSize& size,
     int msaaSampleCount,
     OpacityMode opacityMode,
     AccelerationMode accelerationMode,
-    sk_sp<SkColorSpace> colorSpace,
+    const gfx::ColorSpace& colorSpace,
+    bool skSurfacesUseColorSpace,
     SkColorType colorType)
     : m_contextProvider(std::move(contextProvider)),
       m_logger(WTF::wrapUnique(new Logger)),
       m_weakPtrFactory(this),
       m_imageBuffer(0),
       m_msaaSampleCount(msaaSampleCount),
       m_bytesAllocated(0),
       m_haveRecordedDrawCommands(false),
       m_destructionInProgress(false),
       m_filterQuality(kLow_SkFilterQuality),
       m_isHidden(false),
       m_isDeferralEnabled(true),
       m_isRegisteredTaskObserver(false),
       m_renderingTaskCompletedForCurrentFrame(false),
       m_softwareRenderingWhileHidden(false),
       m_lastImageId(0),
       m_lastFilter(GL_LINEAR),
       m_accelerationMode(accelerationMode),
       m_opacityMode(opacityMode),
       m_size(size),
       m_colorSpace(colorSpace),
+      m_skSurfacesUseColorSpace(skSurfacesUseColorSpace),
       m_colorType(colorType) {
   DCHECK(m_contextProvider);
   DCHECK(!m_contextProvider->isSoftwareRendering());
+  DCHECK(m_colorSpace.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(m_destructionInProgress);
 #if USE_IOSURFACE_FOR_2D_CANVAS
   clearCHROMIUMImageCache();
@@ skipping 106 matching lines @@
 
   info.m_imageInfo = imageInfo;
   bool isOverlayCandidate = true;
   bool secureOutputOnly = false;
   info.m_mailbox = mailbox;
 
   *outMailbox =
       cc::TextureMailbox(mailbox, syncToken, textureTarget, gfx::Size(m_size),
                          isOverlayCandidate, secureOutputOnly);
   if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
-    gfx::ColorSpace colorSpace =
-        gfx::ColorSpace::FromSkColorSpace(m_colorSpace);
-    outMailbox->set_color_space(colorSpace);
-    imageInfo->m_gpuMemoryBuffer->SetColorSpaceForScanout(colorSpace);
+    outMailbox->set_color_space(m_colorSpace);
+    imageInfo->m_gpuMemoryBuffer->SetColorSpaceForScanout(m_colorSpace);
   }
 
   gl->BindTexture(GC3D_TEXTURE_RECTANGLE_ARB, 0);
 
   // Because we are changing the texture binding without going through skia,
   // we must dirty the context.
   grContext->resetContext(kTextureBinding_GrGLBackendState);
 
   return true;
 }
@@ skipping 223 matching lines @@
                   &copyPaint);  // GPU readback
   m_hibernationImage = tempHibernationSurface->makeImageSnapshot();
   m_surface.reset();  // destroy the GPU-backed buffer
   m_layer->clearTexture();
 #if USE_IOSURFACE_FOR_2D_CANVAS
   clearCHROMIUMImageCache();
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
   m_logger->didStartHibernating();
 }
 
+sk_sp<SkColorSpace> Canvas2DLayerBridge::skSurfaceColorSpace() const {
+  if (m_skSurfacesUseColorSpace)
+    return m_colorSpace.ToSkColorSpace();
+  return nullptr;
+}
+
 void Canvas2DLayerBridge::reportSurfaceCreationFailure() {
   if (!m_surfaceCreationFailedAtLeastOnce) {
     // 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::GPUAccelerated2DCanvasSurfaceCreationFailed);
     m_surfaceCreationFailedAtLeastOnce = true;
   }
 }
@@ skipping 10 matching lines @@
   bool wantAcceleration = shouldAccelerate(hint);
   if (CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU && isHidden() &&
       wantAcceleration) {
     wantAcceleration = false;
     m_softwareRenderingWhileHidden = true;
   }
 
   bool surfaceIsAccelerated;
   m_surface = createSkSurface(
       wantAcceleration ? m_contextProvider->grContext() : nullptr, m_size,
-      m_msaaSampleCount, m_opacityMode, m_colorSpace, m_colorType,
+      m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(), m_colorType,
       &surfaceIsAccelerated);
 
   if (m_surface) {
     // Always save an initial frame, to support resetting the top level matrix
     // and clip.
     m_surface->getCanvas()->save();
   } else {
     reportSurfaceCreationFailure();
   }
 
@@ skipping 284 matching lines @@
   gpu::gles2::GLES2Interface* sharedGL = nullptr;
   m_layer->clearTexture();
   m_contextProvider = WTF::wrapUnique(
       Platform::current()->createSharedOffscreenGraphicsContext3DProvider());
   if (m_contextProvider)
     sharedGL = m_contextProvider->contextGL();
 
   if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* grCtx = m_contextProvider->grContext();
     bool surfaceIsAccelerated;
-    sk_sp<PaintSurface> surface(
-        createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode,
-                        m_colorSpace, m_colorType, &surfaceIsAccelerated));
-
+    sk_sp<PaintSurface> surface(createSkSurface(
+        grCtx, m_size, m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(),
+        m_colorType, &surfaceIsAccelerated));
     if (!m_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 && surfaceIsAccelerated) {
       m_surface = std::move(surface);
       // FIXME: draw sad canvas picture into new buffer crbug.com/243842
     }
   }
   if (m_imageBuffer)
     m_imageBuffer->updateGPUMemoryUsage();
 
   return m_surface.get();
 }
 
-static gfx::ColorSpace SkColorSpaceToColorSpace(
-    const SkColorSpace* skColorSpace) {
-  // TODO(crbug.com/634102): Eliminate this clumsy conversion by unifying
-  // SkColorSpace and gfx::ColorSpace.
-  if (!skColorSpace)
-    return gfx::ColorSpace();
-
-  gfx::ColorSpace::TransferID transferID =
-      gfx::ColorSpace::TransferID::UNSPECIFIED;
-  if (skColorSpace->gammaCloseToSRGB()) {
-    transferID = gfx::ColorSpace::TransferID::IEC61966_2_1;
-  } else if (skColorSpace->gammaIsLinear()) {
-    transferID = gfx::ColorSpace::TransferID::LINEAR;
-  } else {
-    // TODO(crbug.com/634102): Not all curve type are supported
-    DCHECK(false);
-  }
-
-  // TODO(crbug.com/634102): No primary conversions are performed.
-  // Rec-709 is assumed.
-  return gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT709, transferID,
-                         gfx::ColorSpace::MatrixID::RGB,
-                         gfx::ColorSpace::RangeID::FULL);
-}
-
 bool Canvas2DLayerBridge::PrepareTextureMailbox(
     cc::TextureMailbox* outMailbox,
     std::unique_ptr<cc::SingleReleaseCallback>* outReleaseCallback) {
   if (m_destructionInProgress) {
     // It can be hit in the following sequence.
     // 1. Canvas draws something.
     // 2. The compositor begins the frame.
     // 3. Javascript makes a context be lost.
     // 4. Here.
     return false;
@@ skipping 21 matching lines @@
   // Early exit if canvas was not drawn to since last prepareMailbox.
   GLenum filter = getGLFilter();
   if (image->uniqueID() == m_lastImageId && filter == m_lastFilter)
     return false;
   m_lastImageId = image->uniqueID();
   m_lastFilter = filter;
 
   if (!prepareMailboxFromImage(std::move(image), outMailbox))
     return false;
   outMailbox->set_nearest_neighbor(getGLFilter() == GL_NEAREST);
-  gfx::ColorSpace colorSpace = SkColorSpaceToColorSpace(m_colorSpace.get());
-  outMailbox->set_color_space(colorSpace);
+  outMailbox->set_color_space(m_colorSpace);
 
   auto func =
       WTF::bind(&Canvas2DLayerBridge::mailboxReleased,
                 m_weakPtrFactory.createWeakPtr(), outMailbox->mailbox());
   *outReleaseCallback =
       cc::SingleReleaseCallback::Create(convertToBaseCallback(std::move(func)));
   return true;
 }
 
 void Canvas2DLayerBridge::mailboxReleased(const gpu::Mailbox& mailbox,
@@ skipping 186 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink