cc: Populate SkColorSpace for raster from resource gfx::ColorSpace

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 23 matching lines @@
 #include "skia/ext/texture_handle.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
+#include "ui/gfx/icc_profile.h"
 #include "ui/gl/trace_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
 
@@ skipping 330 matching lines @@
 
 ResourceProvider::ResourceProvider(
     ContextProvider* compositor_context_provider,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     size_t id_allocation_chunk_size,
     bool delegated_sync_points_required,
     bool use_gpu_memory_buffer_resources,
+    bool enable_color_correct_rendering,
     const BufferToTextureTargetMap& buffer_to_texture_target_map)
     : compositor_context_provider_(compositor_context_provider),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       blocking_main_thread_task_runner_(blocking_main_thread_task_runner),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       delegated_sync_points_required_(delegated_sync_points_required),
       default_resource_type_(use_gpu_memory_buffer_resources
                                  ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
                                  : RESOURCE_TYPE_GL_TEXTURE),
       use_texture_storage_ext_(false),
       use_texture_format_bgra_(false),
       use_texture_usage_hint_(false),
       use_compressed_texture_etc1_(false),
       yuv_resource_format_(LUMINANCE_8),
       max_texture_size_(0),
       best_texture_format_(RGBA_8888),
       best_render_buffer_format_(RGBA_8888),
+      enable_color_correct_rendering_(enable_color_correct_rendering),
       id_allocation_chunk_size_(id_allocation_chunk_size),
       use_sync_query_(false),
       buffer_to_texture_target_map_(buffer_to_texture_target_map),
       tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
   DCHECK(id_allocation_chunk_size_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
@@ skipping 388 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) {
+sk_sp<SkColorSpace> ResourceProvider::GetResourceSkColorSpace(
+    const Resource* resource) const {
   // 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(),
-        ColorSpaceToSkColorSpace(resource->color_space));
+    SkImageInfo source_info =
+        SkImageInfo::MakeN32Premul(image_size.width(), image_size.height(),
+                                   GetResourceSkColorSpace(resource));
     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 227 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);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource->locked_for_write);
   if (sync_token_.HasData())
     resource->UpdateSyncToken(sync_token_);
   if (synchronized_)
     resource->SetSynchronized();
@@ skipping 44 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, &surface_props);
+      context_provider->GrContext(), desc, resource_lock->sk_color_space(),
+      &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(),
-      ColorSpaceToSkColorSpace(resource->color_space));
+      GetResourceSkColorSpace(resource));
   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);
+  resource_provider->PopulateSkBitmapWithResource(&sk_bitmap_, resource);
 }
 
 ResourceProvider::ScopedReadLockSoftware::~ScopedReadLockSoftware() {
   resource_provider_->UnlockForRead(resource_id_);
 }
 
 ResourceProvider::ScopedReadLockSkImage::ScopedReadLockSkImage(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider), resource_id_(resource_id) {
   const Resource* resource = resource_provider->LockForRead(resource_id);
   if (resource->gl_id) {
     GrGLTextureInfo texture_info;
     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,
-        kPremul_SkAlphaType, ColorSpaceToSkColorSpace(resource->color_space),
-        nullptr, nullptr);
+        kPremul_SkAlphaType,
+        resource_provider->GetResourceSkColorSpace(resource), nullptr, nullptr);
   } else if (resource->pixels) {
     SkBitmap sk_bitmap;
-    ResourceProvider::PopulateSkBitmapWithResource(&sk_bitmap, resource);
+    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) {
-  ResourceProvider::PopulateSkBitmapWithResource(
+  resource_provider->PopulateSkBitmapWithResource(
       &sk_bitmap_, resource_provider->LockForWrite(resource_id));
   DCHECK(valid());
 }
 
 ResourceProvider::ScopedWriteLockSoftware::~ScopedWriteLockSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource);
   resource->SetSynchronized();
   resource_provider_->UnlockForWrite(resource);
@@ skipping 11 matching lines @@
   gpu_memory_buffer_ = std::move(resource->gpu_memory_buffer);
   resource->gpu_memory_buffer = nullptr;
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   Resource* resource = resource_provider_->GetResource(resource_id_);
   DCHECK(resource);
   if (gpu_memory_buffer_) {
+    if (resource_provider_->enable_color_correct_rendering_)
+      gpu_memory_buffer_->SetColorSpaceForScanout(resource->color_space);
     DCHECK(!resource->gpu_memory_buffer);
     resource_provider_->LazyCreate(resource);
     resource->gpu_memory_buffer = std::move(gpu_memory_buffer_);
     resource->allocated = true;
     resource_provider_->LazyCreateImage(resource);
     resource->dirty_image = true;
     resource->is_overlay_candidate = true;
     // GpuMemoryBuffer provides direct access to the memory used by the GPU.
     // Read lock fences are required to ensure that we're not trying to map a
     // buffer that is currently in-use by the GPU.
@@ skipping 561 matching lines @@
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   ResourceFormat format = resource->format;
   gl->BindTexture(resource->target, resource->gl_id);
   if (resource->type == RESOURCE_TYPE_GPU_MEMORY_BUFFER) {
     resource->gpu_memory_buffer =
         gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
             size, BufferFormat(format), resource->usage,
             gpu::kNullSurfaceHandle);
+    if (resource->gpu_memory_buffer && enable_color_correct_rendering_) {
+      resource->gpu_memory_buffer->SetColorSpaceForScanout(
+          resource->color_space);
+    }
+
     LazyCreateImage(resource);
     resource->dirty_image = true;
     resource->is_overlay_candidate = true;
     // GpuMemoryBuffer provides direct access to the memory used by the GPU.
     // Read lock fences are required to ensure that we're not trying to map a
     // buffer that is currently in-use by the GPU.
     resource->read_lock_fences_enabled = true;
   } else if (use_texture_storage_ext_ &&
              IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
              (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
@@ skipping 165 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc