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

cc/resources/video_resource_updater.cc

 // Copyright 2013 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/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 156 matching lines @@
 }
 
 VideoResourceUpdater::~VideoResourceUpdater() {
   for (const PlaneResource& plane_resource : all_resources_)
     resource_provider_->DeleteResource(plane_resource.resource_id());
 }
 
 VideoResourceUpdater::ResourceList::iterator
 VideoResourceUpdater::AllocateResource(const gfx::Size& plane_size,
                                        ResourceFormat format,
+                                       const gfx::ColorSpace& color_space,
                                        bool has_mailbox,
                                        bool immutable_hint) {
   // TODO(danakj): Abstract out hw/sw resource create/delete from
   // ResourceProvider and stop using ResourceProvider in this class.
   const ResourceId resource_id = resource_provider_->CreateResource(
       plane_size, immutable_hint ? ResourceProvider::TEXTURE_HINT_IMMUTABLE
                                  : ResourceProvider::TEXTURE_HINT_DEFAULT,
-      format);
+      format, color_space);
   if (resource_id == 0)
     return all_resources_.end();
 
   gpu::Mailbox mailbox;
   if (has_mailbox) {
     DCHECK(context_provider_);
 
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
 
     gl->GenMailboxCHROMIUM(mailbox.name);
@@ skipping 154 matching lines @@
         if (!it->has_refs() && !in_use) {
           // We found a resource with the correct size that we can overwrite.
           resource_it = it;
         }
       }
     }
 
     // Check if we need to allocate a new resource.
     if (resource_it == all_resources_.end()) {
       const bool is_immutable = true;
-      resource_it =
-          AllocateResource(output_plane_resource_size, output_resource_format,
-                           !software_compositor, is_immutable);
+      resource_it = AllocateResource(
+          output_plane_resource_size, output_resource_format,
+          video_frame->ColorSpace(), !software_compositor, is_immutable);
     }
     if (resource_it == all_resources_.end())
       break;
 
     resource_it->add_ref();
     plane_resources.push_back(resource_it);
   }
 
   if (plane_resources.size() != output_plane_count) {
     // Allocation failed, nothing will be returned so restore reference counts.
@@ skipping 204 matching lines @@
             ResourceProvider::TEXTURE_HINT_IMMUTABLE) {
       resource = it;
       break;
     }
   }
 
   // Otherwise allocate a new resource.
   if (resource == all_resources_.end()) {
     const bool is_immutable = false;
     resource = AllocateResource(output_plane_resource_size, copy_target_format,
-                                true, is_immutable);
+                                video_frame->ColorSpace(), true, is_immutable);
   }
 
   resource->add_ref();
 
   ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
                                            resource->resource_id(), false);
   DCHECK_EQ(
       resource_provider_->GetResourceTextureTarget(resource->resource_id()),
       (GLenum)GL_TEXTURE_2D);
 
@@ skipping 98 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc