cc: Move output color space from DrawingFrame to RenderPass

cc/output/direct_renderer.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/output/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
@@ skipping 191 matching lines @@
 
   for (auto& pass : render_passes_in_draw_order) {
     auto& resource = render_pass_textures_[pass->id];
     if (!resource)
       resource = ScopedResource::Create(resource_provider_);
   }
 }
 
 void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                float device_scale_factor,
-                               const gfx::ColorSpace& device_color_space,
                                const gfx::Size& device_viewport_size) {
   DCHECK(visible_);
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS(
       "Renderer4.renderPassCount",
       base::saturated_cast<int>(render_passes_in_draw_order->size()));
 
   RenderPass* root_render_pass = render_passes_in_draw_order->back().get();
   DCHECK(root_render_pass);
 
@@ skipping 16 matching lines @@
 
   current_frame_valid_ = true;
   current_frame_ = DrawingFrame();
   current_frame()->render_passes_in_draw_order = render_passes_in_draw_order;
   current_frame()->root_render_pass = root_render_pass;
   current_frame()->root_damage_rect = root_render_pass->damage_rect;
   current_frame()->root_damage_rect.Union(
       overlay_processor_->GetAndResetOverlayDamage());
   current_frame()->root_damage_rect.Intersect(gfx::Rect(device_viewport_size));
   current_frame()->device_viewport_size = device_viewport_size;
-  current_frame()->device_color_space = device_color_space;
 
   // Only reshape when we know we are going to draw. Otherwise, the reshape
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
   bool frame_has_alpha =
       current_frame()->root_render_pass->has_transparent_background;
   bool use_stencil = overdraw_feedback_;
   if (device_viewport_size != reshape_surface_size_ ||
       device_scale_factor != reshape_device_scale_factor_ ||
-      device_color_space != reshape_device_color_space_ ||
+      root_render_pass->color_space != reshape_device_color_space_ ||
       frame_has_alpha != reshape_has_alpha_ ||
       use_stencil != reshape_use_stencil_) {
     reshape_surface_size_ = device_viewport_size;
     reshape_device_scale_factor_ = device_scale_factor;
-    reshape_device_color_space_ = device_color_space;
+    reshape_device_color_space_ = root_render_pass->color_space;
     reshape_has_alpha_ =
         current_frame()->root_render_pass->has_transparent_background;
     reshape_use_stencil_ = overdraw_feedback_;
     output_surface_->Reshape(
         reshape_surface_size_, reshape_device_scale_factor_,
         reshape_device_color_space_, reshape_has_alpha_, reshape_use_stencil_);
   }
 
   BeginDrawingFrame();
 
@@ skipping 318 matching lines @@
     return true;
   }
 
   ScopedResource* texture = render_pass_textures_[render_pass->id].get();
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
   size.Enlarge(enlarge_pass_texture_amount_.width(),
                enlarge_pass_texture_amount_.height());
   if (!texture->id()) {
-    texture->Allocate(size,
-                      ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
-                      BackbufferFormat(), current_frame()->device_color_space);
+    texture->Allocate(
+        size, ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
+        BackbufferFormat(), current_frame()->current_render_pass->color_space);
   }
   DCHECK(texture->id());
 
   if (BindFramebufferToTexture(texture)) {
     InitializeViewport(current_frame(), render_pass->output_rect,
                        gfx::Rect(render_pass->output_rect.size()),
                        texture->size());
     return true;
   }
 
   return false;
 }
 
 bool DirectRenderer::HasAllocatedResourcesForTesting(int render_pass_id) const {
   auto iter = render_pass_textures_.find(render_pass_id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 void DirectRenderer::SetCurrentFrameForTesting(const DrawingFrame& frame) {
   current_frame_valid_ = true;
   current_frame_ = frame;
 }
 
 }  // namespace cc