cc: Use SkCreateColorSpaceXformCanvas for color transforms

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 865 matching lines @@
     // Software resources are immutable; they cannot change format or be
     // resized.
     return true;
   }
 }
 
 ResourceProvider::TextureHint ResourceProvider::GetTextureHint(ResourceId id) {
   return GetResource(id)->hint;
 }
 
-sk_sp<SkColorSpace> ResourceProvider::GetResourceSkColorSpace(
+gfx::ColorSpace ResourceProvider::GetResourceColorSpaceForRaster(
     const Resource* resource) const {
   if (!settings_.enable_color_correct_rasterization)
-    return nullptr;
-  // Returning the nonlinear blended color space matches the expectation of the
-  // web that colors are blended in the output color space, not in a
-  // physically-based linear space.
-  return resource->color_space.ToNonlinearBlendedSkColorSpace();
+    return gfx::ColorSpace();
+  return resource->color_space;
 }
 
 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(),
-                                   GetResourceSkColorSpace(resource));
+        SkImageInfo::MakeN32Premul(image_size.width(), image_size.height());
     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 259 matching lines @@
     resource_provider_->BindImageForSampling(resource);
   if (create_mailbox) {
     resource_provider_->CreateMailboxAndBindResource(
         resource_provider_->ContextGL(), resource);
   }
   texture_id_ = resource->gl_id;
   target_ = resource->target;
   format_ = resource->format;
   size_ = resource->size;
   mailbox_ = resource->mailbox();
-  sk_color_space_ = resource_provider->GetResourceSkColorSpace(resource);
+  color_space_ = resource_provider->GetResourceColorSpaceForRaster(resource);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource->locked_for_write);
   // It's not sufficient to check sync_token_.HasData() here because the sync
   // might be null because of context loss. Even in that case we want to set the
   // sync token because it's checked in PrepareSendToParent while drawing.
   if (has_sync_token_)
@@ skipping 47 matching lines @@
   uint32_t flags =
       use_distance_field_text ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
   // Use unknown pixel geometry to disable LCD text.
   SkSurfaceProps surface_props(flags, kUnknown_SkPixelGeometry);
   if (can_use_lcd_text) {
     // LegacyFontHost will get LCD text and skia figures out what type to use.
     surface_props =
         SkSurfaceProps(flags, SkSurfaceProps::kLegacyFontHost_InitType);
   }
   sk_surface_ = SkSurface::MakeFromBackendTextureAsRenderTarget(
-      context_provider->GrContext(), desc, resource_lock->sk_color_space(),
-      &surface_props);
+      context_provider->GrContext(), desc, nullptr, &surface_props);
 }
 
 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(),
-      GetResourceSkColorSpace(resource));
+  SkImageInfo info = SkImageInfo::MakeN32Premul(resource->size.width(),
+                                                resource->size.height());
   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);
   resource_provider->PopulateSkBitmapWithResource(&sk_bitmap_, resource);
 }
@@ skipping 12 matching lines @@
     texture_info.fID = resource->gl_id;
     texture_info.fTarget = resource->target;
     GrBackendTextureDesc desc;
     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,
-        kPremul_SkAlphaType,
-        resource_provider->GetResourceSkColorSpace(resource), nullptr, nullptr);
+        kPremul_SkAlphaType);
   } else if (resource->pixels) {
     SkBitmap sk_bitmap;
     resource_provider->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.
     // Renderers need to silently handle locks failing until this race
     // is fixed.  DCHECK that this is the only case where there are no pixels.
     DCHECK(!resource->shared_bitmap_id.IsZero());
   }
 }
 
 ResourceProvider::ScopedReadLockSkImage::~ScopedReadLockSkImage() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedWriteLockSoftware::ScopedWriteLockSoftware(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
   Resource* resource = resource_provider->LockForWrite(resource_id);
   resource_provider->PopulateSkBitmapWithResource(&sk_bitmap_, resource);
-  sk_color_space_ = resource_provider->GetResourceSkColorSpace(resource);
+  color_space_ = resource_provider->GetResourceColorSpaceForRaster(resource);
   DCHECK(valid());
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource);
   resource->SetSynchronized();
   resource_provider_->UnlockForWrite(resource);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
   Resource* resource = resource_provider->LockForWrite(resource_id);
   DCHECK(IsGpuResourceType(resource->type));
   format_ = resource->format;
   size_ = resource->size;
   usage_ = resource->usage;
   gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer);
   resource->gpu_memory_buffer = nullptr;
+  color_space_ = resource_provider->GetResourceColorSpaceForRaster(resource);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource);
   if (gpu_memory_buffer_) {
     // Note that this impacts overlay compositing, not rasterization.
     if (resource_provider_->settings_.enable_color_correct_rasterization)
@@ skipping 811 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc