Fix the linear-rgb canvas color space so that it renders

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 67 matching lines @@
   // The id of the texture bound to the CHROMIUM image.
   const GLuint m_textureId;
 };
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
 static sk_sp<SkSurface> createSkSurface(GrContext* gr,
                                         const IntSize& size,
                                         int msaaSampleCount,
                                         OpacityMode opacityMode,
                                         sk_sp<SkColorSpace> colorSpace,
+                                        SkColorType colorType,
                                         bool* surfaceIsAccelerated) {
   if (gr)
     gr->resetContext();
 
   SkAlphaType alphaType =
       (Opaque == opacityMode) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-  SkImageInfo info =
-      SkImageInfo::MakeN32(size.width(), size.height(), alphaType, colorSpace);
+  SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
+                                       alphaType, colorSpace);
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
   sk_sp<SkSurface> surface;
 
   if (gr) {
     *surfaceIsAccelerated = true;
     surface = SkSurface::MakeRenderTarget(
         gr, SkBudgeted::kNo, info, msaaSampleCount,
         Opaque == opacityMode ? 0 : &disableLCDProps);
   }
 
@@ skipping 12 matching lines @@
   }
   return surface;
 }
 
 Canvas2DLayerBridge::Canvas2DLayerBridge(
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const IntSize& size,
     int msaaSampleCount,
     OpacityMode opacityMode,
     AccelerationMode accelerationMode,
-    sk_sp<SkColorSpace> colorSpace)
+    sk_sp<SkColorSpace> colorSpace,
+    SkColorType colorType)
     : m_contextProvider(std::move(contextProvider)),
       m_logger(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_colorSpace(colorSpace),
+      m_colorType(colorType) {
   DCHECK(m_contextProvider);
   DCHECK(!m_contextProvider->isSoftwareRendering());
   // 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);
@@ skipping 385 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, &surfaceIsAccelerated);
+      m_msaaSampleCount, m_opacityMode, m_colorSpace, 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();
   }
 
   if (m_surface && surfaceIsAccelerated && !m_layer) {
@@ skipping 278 matching lines @@
   gpu::gles2::GLES2Interface* sharedGL = nullptr;
   m_layer->clearTexture();
   m_contextProvider = 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<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount,
-                                             m_opacityMode, m_colorSpace,
-                                             &surfaceIsAccelerated));
+    sk_sp<SkSurface> surface(
+        createSkSurface(grCtx, m_size, m_msaaSampleCount, m_opacityMode,
+                        m_colorSpace, 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);
@@ skipping 266 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink