cc: Move output color space from DrawingFrame to RenderPass

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 864 matching lines @@
   return backdrop_rect;
 }
 
 std::unique_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
     const gfx::Rect& bounding_rect) {
   std::unique_ptr<ScopedResource> device_background_texture =
       ScopedResource::Create(resource_provider_);
   // CopyTexImage2D fails when called on a texture having immutable storage.
   device_background_texture->Allocate(
       bounding_rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT,
-      BackbufferFormat(), current_frame()->device_color_space);
+      BackbufferFormat(), current_frame()->current_render_pass->color_space);
   {
     ResourceProvider::ScopedWriteLockGL lock(
         resource_provider_, device_background_texture->id(), false);
     GetFramebufferTexture(lock.texture_id(), bounding_rect);
   }
   return device_background_texture;
 }
 
 sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     const RenderPassDrawQuad* quad,
@@ skipping 131 matching lines @@
   DrawRenderPassDrawQuadParams params;
   params.quad = quad;
   params.clip_region = clip_region;
   params.window_matrix = current_frame()->window_matrix;
   params.projection_matrix = current_frame()->projection_matrix;
   if (bypass != render_pass_bypass_quads_.end()) {
     TileDrawQuad* tile_quad = &bypass->second;
     // RGBA_8888 here is arbitrary and unused.
     Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
                            ResourceFormat::RGBA_8888,
-                           current_frame()->device_color_space);
+                           current_frame()->current_render_pass->color_space);
     // The projection matrix used by GLRenderer has a flip.  As tile texture
     // inputs are oriented opposite to framebuffer outputs, don't flip via
     // texture coords and let the projection matrix naturallyd o it.
     params.flip_texture = false;
     params.contents_texture = &tile_resource;
     DrawRenderPassQuadInternal(&params);
   } else {
     ScopedResource* contents_texture =
         render_pass_textures_[quad->render_pass_id].get();
     DCHECK(contents_texture);
@@ skipping 254 matching lines @@
   if (params->mask_resource_lock) {
     mask_mode = HAS_MASK;
     sampler_type =
         SamplerTypeFromTextureTarget(params->mask_resource_lock->target());
   }
 
   SetUseProgram(ProgramKey::RenderPass(
                     tex_coord_precision, sampler_type, shader_blend_mode,
                     params->use_aa ? USE_AA : NO_AA, mask_mode,
                     mask_for_background, params->use_color_matrix),
-                current_frame()->device_color_space);
+                current_frame()->current_render_pass->color_space);
 }
 
 void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
   gfx::RectF tex_rect(params->src_offset.x(), params->src_offset.y(),
                       params->dst_rect.width(), params->dst_rect.height());
   gfx::Size texture_size;
   if (params->filter_image) {
     texture_size.set_width(params->filter_image->width());
     texture_size.set_height(params->filter_image->height());
   } else {
@@ skipping 762 matching lines @@
                                                : YUV_NO_ALPHA_TEXTURE;
   UVTextureMode uv_texture_mode =
       quad->v_plane_resource_id() == quad->u_plane_resource_id()
           ? UV_TEXTURE_MODE_UV
           : UV_TEXTURE_MODE_U_V;
 
   // TODO(ccameron): There are currently three sources of the color space: the
   // resource, quad->color_space, and quad->video_color_space. Remove two of
   // them.
   gfx::ColorSpace src_color_space = quad->video_color_space;
-  gfx::ColorSpace dst_color_space = current_frame()->device_color_space;
+  gfx::ColorSpace dst_color_space =
+      current_frame()->current_render_pass->color_space;
   if (!base::FeatureList::IsEnabled(media::kVideoColorManagement)) {
     if (!settings_->enable_color_correct_rendering)
       dst_color_space = gfx::ColorSpace();
     switch (quad->color_space) {
       case YUVVideoDrawQuad::REC_601:
         src_color_space = gfx::ColorSpace::CreateREC601();
         break;
       case YUVVideoDrawQuad::REC_709:
         src_color_space = gfx::ColorSpace::CreateREC709();
         break;
@@ skipping 907 matching lines @@
     case NO_BINDING:
       break;
   }
   bound_geometry_ = binding;
 }
 
 void GLRenderer::SetUseProgram(const ProgramKey& program_key,
                                const gfx::ColorSpace& src_color_space) {
   gfx::ColorSpace dst_color_space;
   if (settings_->enable_color_correct_rendering)
-    dst_color_space = current_frame()->device_color_space;
+    dst_color_space = current_frame()->current_render_pass->color_space;
   SetUseProgram(program_key, src_color_space, dst_color_space);
 }
 
 void GLRenderer::SetUseProgram(const ProgramKey& program_key_no_color,
                                const gfx::ColorSpace& src_color_space,
                                const gfx::ColorSpace& dst_color_space) {
   ProgramKey program_key = program_key_no_color;
   if (src_color_space.IsValid() && dst_color_space.IsValid())
     program_key.SetColorConversionMode(COLOR_CONVERSION_MODE_LUT);
 
@@ skipping 256 matching lines @@
   // memory fragmentation. https://crbug.com/146070. This also allows IOSurfaces
   // to be more easily reused during a resize operation.
   uint32_t iosurface_multiple = 64;
   uint32_t iosurface_width = MathUtil::UncheckedRoundUp(
       static_cast<uint32_t>(updated_dst_rect.width()), iosurface_multiple);
   uint32_t iosurface_height = MathUtil::UncheckedRoundUp(
       static_cast<uint32_t>(updated_dst_rect.height()), iosurface_multiple);
 
   *resource = overlay_resource_pool_->AcquireResource(
       gfx::Size(iosurface_width, iosurface_height), ResourceFormat::RGBA_8888,
-      current_frame()->device_color_space);
+      current_frame()->current_render_pass->color_space);
   *new_bounds =
       gfx::RectF(updated_dst_rect.x(), updated_dst_rect.y(),
                  (*resource)->size().width(), (*resource)->size().height());
 
   // Calculate new projection and window matrices for a minimally sized viewport
   // using InitializeViewport(). This requires creating a dummy DrawingFrame.
   {
     DrawingFrame dummy_frame;
     force_drawing_frame_framebuffer_unflipped_ = true;
     gfx::Rect frame_rect =
@@ skipping 215 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc