cc: Add gfx::ColorSpace to cc::ResourceProvider resource creation

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 875 matching lines @@
   backdrop_rect.Intersect(MoveFromDrawToWindowSpace(
       frame, frame->current_render_pass->output_rect));
   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,
-      resource_provider_->best_texture_format());
+  device_background_texture->Allocate(bounding_rect.size(),
+                                      ResourceProvider::TEXTURE_HINT_DEFAULT,
+                                      resource_provider_->best_texture_format(),
+                                      output_surface_->device_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 123 matching lines @@
   DrawRenderPassDrawQuadParams params;
   params.quad = quad;
   params.frame = frame;
   params.clip_region = clip_region;
   params.window_matrix = frame->window_matrix;
   params.projection_matrix = 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);
+                           ResourceFormat::RGBA_8888,
+                           output_surface_->device_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 1338 matching lines @@
     yuv_to_rgb_multiplied[i] = yuv_to_rgb[i] * quad->resource_multiplier;
 
   for (int i = 0; i < 3; ++i) {
     yuv_adjust_with_offset[i] =
         yuv_adjust[i] * adjustment_multiplier / quad->resource_multiplier -
         quad->resource_offset;
   }
 
   if (lut_texture_location != -1) {
     unsigned int lut_texture = color_lut_cache_.GetLUT(
-        quad->video_color_space, output_surface_->color_space(), 32);
+        quad->video_color_space, output_surface_->device_color_space(), 32);
     gl_->ActiveTexture(GL_TEXTURE5);
     gl_->BindTexture(GL_TEXTURE_2D, lut_texture);
     gl_->Uniform1i(lut_texture_location, 5);
     gl_->ActiveTexture(GL_TEXTURE0);
   }
 
   if (resource_multiplier_location != -1) {
     gl_->Uniform1f(resource_multiplier_location, quad->resource_multiplier);
   }
 
@@ skipping 1564 matching lines @@
     gfx::QuadF device_layer_quad = MathUtil::MapQuad(
         params.contents_device_transform, SharedGeometryQuad(), &clipped);
     LayerQuad device_layer_edges(device_layer_quad);
     InflateAntiAliasingDistances(device_layer_quad, &device_layer_edges,
                                  params.edge);
   }
 
   // Establish destination texture.
   *resource = overlay_resource_pool_->AcquireResource(
       gfx::Size(updated_dst_rect.width(), updated_dst_rect.height()),
-      ResourceFormat::RGBA_8888);
+      ResourceFormat::RGBA_8888, output_surface_->device_color_space());
   ResourceProvider::ScopedWriteLockGL destination(resource_provider_,
                                                   (*resource)->id(), false);
   GLuint temp_fbo;
 
   gl_->GenFramebuffers(1, &temp_fbo);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, temp_fbo);
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                             destination.target(), destination.texture_id(), 0);
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
          GL_FRAMEBUFFER_COMPLETE);
@@ skipping 63 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc