cc: Clarify that color spaces are for raster

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 389 matching lines @@
     : marked_for_deletion(false), needs_sync_tokens(true) {}
 
 ResourceProvider::Child::Child(const Child& other) = default;
 
 ResourceProvider::Child::~Child() {}
 
 ResourceProvider::Settings::Settings(
     ContextProvider* compositor_context_provider,
     bool delegated_sync_points_required,
     bool use_gpu_memory_buffer_resources,
-    bool enable_color_correct_rendering)
+    bool enable_color_correct_rasterization)
     : default_resource_type(use_gpu_memory_buffer_resources
                                 ? RESOURCE_TYPE_GPU_MEMORY_BUFFER
                                 : RESOURCE_TYPE_GL_TEXTURE),
-      enable_color_correct_rendering(enable_color_correct_rendering),
+      enable_color_correct_rasterization(enable_color_correct_rasterization),
       delegated_sync_points_required(delegated_sync_points_required) {
   if (!compositor_context_provider) {
     default_resource_type = RESOURCE_TYPE_BITMAP;
     // Pick an arbitrary limit here similar to what hardware might.
     max_texture_size = 16 * 1024;
     best_texture_format = RGBA_8888;
     return;
   }
 
   DCHECK(IsGpuResourceType(default_resource_type));
@@ skipping 22 matching lines @@
 }
 
 ResourceProvider::ResourceProvider(
     ContextProvider* compositor_context_provider,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     size_t id_allocation_chunk_size,
     bool delegated_sync_points_required,
     bool use_gpu_memory_buffer_resources,
-    bool enable_color_correct_rendering,
+    bool enable_color_correct_rasterization,
     const BufferToTextureTargetMap& buffer_to_texture_target_map)
     : settings_(compositor_context_provider,
                 delegated_sync_points_required,
                 use_gpu_memory_buffer_resources,
-                enable_color_correct_rendering),
+                enable_color_correct_rasterization),
       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_context_provider_(false),
       next_id_(1),
       next_child_(1),
       buffer_to_texture_target_map_(buffer_to_texture_target_map),
       tracing_id_(g_next_resource_provider_tracing_id.GetNext()) {
   DCHECK(id_allocation_chunk_size);
@@ skipping 402 matching lines @@
     return true;
   }
 }
 
 ResourceProvider::TextureHint ResourceProvider::GetTextureHint(ResourceId id) {
   return GetResource(id)->hint;
 }
 
 sk_sp<SkColorSpace> ResourceProvider::GetResourceSkColorSpace(
     const Resource* resource) const {
-  if (!settings_.enable_color_correct_rendering)
+  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();
 }
 
 void ResourceProvider::CopyToResource(ResourceId id,
                                       const uint8_t* image,
                                       const gfx::Size& image_size) {
@@ skipping 460 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_->settings_.enable_color_correct_rendering)
+    // Note that this impacts overlay compositing, not rasterization.
+    if (resource_provider_->settings_.enable_color_correct_rasterization)
       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
@@ skipping 606 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_->CreateGpuMemoryBuffer(
             size, BufferFormat(format), resource->usage,
             gpu::kNullSurfaceHandle);
+    // Note that this impacts overlay compositing, not rasterization.
     if (resource->gpu_memory_buffer &&
-        settings_.enable_color_correct_rendering) {
+        settings_.enable_color_correct_rasterization) {
       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.
@@ skipping 170 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc