Add some plumbing for the color management of canvases

cc/resources/resource_provider.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 654 matching lines @@
     DCHECK(mailbox.IsSharedMemory());
     SharedBitmap* shared_bitmap = mailbox.shared_bitmap();
     uint8_t* pixels = shared_bitmap->pixels();
     DCHECK(pixels);
     resource = InsertResource(
         id, Resource(pixels, shared_bitmap, mailbox.size_in_pixels(),
                      Resource::EXTERNAL, GL_LINEAR));
   }
   resource->allocated = true;
   resource->set_mailbox(mailbox);
+  resource->color_space = mailbox.color_space();
   resource->release_callback_impl =
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
   resource->is_overlay_candidate = mailbox.is_overlay_candidate();
   resource->color_space = mailbox.color_space();
 
   return id;
 }
 
@@ skipping 127 matching lines @@
 }
 
 GLenum ResourceProvider::GetResourceTextureTarget(ResourceId id) {
   return GetResource(id)->target;
 }
 
 ResourceProvider::TextureHint ResourceProvider::GetTextureHint(ResourceId id) {
   return GetResource(id)->hint;
 }
 
+static sk_sp<SkColorSpace> ColorSpaceToSkColorSpace(
+    const gfx::ColorSpace& color_space) {
+  // TODO(crbug.com/634102): Implement conversion for skia-based compositing to
+  // be color-managed
+  return nullptr;
+}
+
 void ResourceProvider::CopyToResource(ResourceId id,
                                       const uint8_t* image,
                                       const gfx::Size& image_size) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(resource->origin == Resource::INTERNAL);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(ReadLockFenceHasPassed(resource));
 
   DCHECK_EQ(image_size.width(), resource->size.width());
   DCHECK_EQ(image_size.height(), resource->size.height());
 
   if (resource->allocated)
     WaitSyncTokenIfNeeded(id);
 
   if (resource->type == RESOURCE_TYPE_BITMAP) {
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
     DCHECK(resource->allocated);
     DCHECK_EQ(RGBA_8888, resource->format);
-    SkImageInfo source_info =
-        SkImageInfo::MakeN32Premul(image_size.width(), image_size.height());
+    SkImageInfo source_info = SkImageInfo::MakeN32Premul(
+        image_size.width(), image_size.height(),
+        ColorSpaceToSkColorSpace(resource->color_space));
     size_t image_stride = image_size.width() * 4;
 
     ScopedWriteLockSoftware lock(this, id);
     SkCanvas dest(lock.sk_bitmap());
     dest.writePixels(source_info, image, image_stride, 0, 0);
   } else {
     ScopedWriteLockGL lock(this, id, false);
     unsigned resource_texture_id = lock.texture_id();
     DCHECK(resource_texture_id);
     GLES2Interface* gl = ContextGL();
@@ skipping 304 matching lines @@
 ResourceProvider::ScopedSkSurfaceProvider::~ScopedSkSurfaceProvider() {
   if (sk_surface_.get()) {
     sk_surface_->prepareForExternalIO();
     sk_surface_.reset();
   }
 }
 
 void ResourceProvider::PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
                                                     const Resource* resource) {
   DCHECK_EQ(RGBA_8888, resource->format);
-  SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
-                                                resource->size.height());
+  SkImageInfo info = SkImageInfo::MakeN32Premul(
+      resource->size.width(), resource->size.height(),
+      ColorSpaceToSkColorSpace(resource->color_space));
   sk_bitmap->installPixels(info, resource->pixels, info.minRowBytes());
 }
 
 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
   const Resource* resource = resource_provider->LockForRead(resource_id);
   ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap_, resource);
 }
@@ skipping 12 matching lines @@
     texture_info.fID = resource->gl_id;
     texture_info.fTarget = resource->target;
     GrBackendTextureDesc desc;
     desc.fFlags = kRenderTarget_GrBackendTextureFlag;
     desc.fWidth = resource->size.width();
     desc.fHeight = resource->size.height();
     desc.fConfig = ToGrPixelConfig(resource->format);
     desc.fOrigin = kTopLeft_GrSurfaceOrigin;
     desc.fTextureHandle = skia::GrGLTextureInfoToGrBackendObject(texture_info);
     sk_image_ = SkImage::MakeFromTexture(
-        resource_provider->compositor_context_provider_->GrContext(), desc);
+        resource_provider->compositor_context_provider_->GrContext(), desc,
+        kPremul_SkAlphaType, ColorSpaceToSkColorSpace(resource->color_space),
+        nullptr, nullptr);
   } else if (resource->pixels) {
     SkBitmap sk_bitmap;
     ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap, resource);
     sk_bitmap.setImmutable();
     sk_image_ = SkImage::MakeFromBitmap(sk_bitmap);
   } else {
     // During render process shutdown, ~RenderMessageFilter which calls
     // ~HostSharedBitmapClient (which deletes shared bitmaps from child)
     // can race with OnBeginFrameDeadline which draws a frame.
     // In these cases, shared bitmaps (and this read lock) won't be valid.
@@ skipping 802 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc