Use gfx::ColorSpace instead of SkColorSpace in Blink

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 881 matching lines @@
   return true;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::createWebGLImageBufferSurface(OpacityMode opacityMode) {
   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(), opacityMode, m_context->skColorSpace(), m_context->colorType()));
+      size(), opacityMode, m_context->skSurfaceColorSpace(),
+      m_context->colorType()));
   if (surface->isValid())
     return std::move(surface);
   return nullptr;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::createAcceleratedImageBufferSurface(
     OpacityMode opacityMode,
     int* msaaSampleCount) {
   if (document().settings()) {
@@ skipping 10 matching lines @@
         CanvasMetrics::Accelerated2DCanvasGPUContextLost);
     return nullptr;
   }
 
   if (contextProvider->isSoftwareRendering())
     return nullptr;  // Don't use accelerated canvas with swiftshader.
 
   std::unique_ptr<ImageBufferSurface> surface =
       WTF::wrapUnique(new Canvas2DImageBufferSurface(
           std::move(contextProvider), size(), *msaaSampleCount, opacityMode,
-          Canvas2DLayerBridge::EnableAcceleration, m_context->skColorSpace(),
-          m_context->colorType()));
+          Canvas2DLayerBridge::EnableAcceleration, m_context->gfxColorSpace(),
+          m_context->skSurfacesUseColorSpace(), m_context->colorType()));
   if (!surface->isValid()) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreationFailed);
     return nullptr;
   }
 
   CanvasMetrics::countCanvasContextUsage(
       CanvasMetrics::GPUAccelerated2DCanvasImageBufferCreated);
   return surface;
 }
 
 std::unique_ptr<ImageBufferSurface>
 HTMLCanvasElement::createUnacceleratedImageBufferSurface(
     OpacityMode opacityMode) {
   if (shouldUseDisplayList()) {
     auto surface = WTF::wrapUnique(new RecordingImageBufferSurface(
         size(), WTF::wrapUnique(new UnacceleratedSurfaceFactory), opacityMode,
-        m_context->skColorSpace(), m_context->colorType()));
+        m_context->skSurfaceColorSpace(), m_context->colorType()));
     if (surface->isValid()) {
       CanvasMetrics::countCanvasContextUsage(
           CanvasMetrics::DisplayList2DCanvasImageBufferCreated);
       return std::move(surface);
     }
     // We fallback to a non-display-list surface without recording a metric
     // here.
   }
 
   auto surfaceFactory = WTF::makeUnique<UnacceleratedSurfaceFactory>();
-  auto surface = surfaceFactory->createSurface(
-      size(), opacityMode, m_context->skColorSpace(), m_context->colorType());
+  auto surface = surfaceFactory->createSurface(size(), opacityMode,
+                                               m_context->skSurfaceColorSpace(),
+                                               m_context->colorType());
   if (surface->isValid()) {
     CanvasMetrics::countCanvasContextUsage(
         CanvasMetrics::Unaccelerated2DCanvasImageBufferCreated);
     return surface;
   }
 
   CanvasMetrics::countCanvasContextUsage(
       CanvasMetrics::Unaccelerated2DCanvasImageBufferCreationFailed);
   return nullptr;
 }
@@ skipping 464 matching lines @@
     // Creates a placeholder layer first before Surface is created.
     m_surfaceLayerBridge->createSolidColorLayer();
   }
 }
 
 void HTMLCanvasElement::OnWebLayerReplaced() {
   setNeedsCompositingUpdate();
 }
 
 }  // namespace blink