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

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 530 matching lines @@
 }
 
 ResourceFormat ResourceProvider::YuvResourceFormat(int bits) const {
   if (bits > 8) {
     return yuv_highbit_resource_format_;
   } else {
     return yuv_resource_format_;
   }
 }
 
-ResourceId ResourceProvider::CreateResource(const gfx::Size& size,
-                                            TextureHint hint,
-                                            ResourceFormat format) {
+ResourceId ResourceProvider::CreateResource(
+    const gfx::Size& size,
+    TextureHint hint,
+    ResourceFormat format,
+    const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
       // GPU memory buffers don't support LUMINANCE_F16.
       if (format != LUMINANCE_F16) {
-        return CreateGLTexture(size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER,
-                               format,
-                               gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
+        return CreateGLTexture(
+            size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER, format,
+            gfx::BufferUsage::GPU_READ_CPU_READ_WRITE, color_space);
       }
     // Fall through and use a regular texture.
     case RESOURCE_TYPE_GL_TEXTURE:
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GL_TEXTURE, format,
-                             gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
+                             gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
+                             color_space);
 
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
-      return CreateBitmap(size);
+      return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceId ResourceProvider::CreateGpuMemoryBufferResource(
     const gfx::Size& size,
     TextureHint hint,
     ResourceFormat format,
-    gfx::BufferUsage usage) {
+    gfx::BufferUsage usage,
+    const gfx::ColorSpace& color_space) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case RESOURCE_TYPE_GPU_MEMORY_BUFFER:
     case RESOURCE_TYPE_GL_TEXTURE: {
       return CreateGLTexture(size, hint, RESOURCE_TYPE_GPU_MEMORY_BUFFER,
-                             format, usage);
+                             format, usage, color_space);
     }
     case RESOURCE_TYPE_BITMAP:
       DCHECK_EQ(RGBA_8888, format);
-      return CreateBitmap(size);
+      return CreateBitmap(size, color_space);
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
-ResourceId ResourceProvider::CreateGLTexture(const gfx::Size& size,
-                                             TextureHint hint,
-                                             ResourceType type,
-                                             ResourceFormat format,
-                                             gfx::BufferUsage usage) {
+ResourceId ResourceProvider::CreateGLTexture(
+    const gfx::Size& size,
+    TextureHint hint,
+    ResourceType type,
+    ResourceFormat format,
+    gfx::BufferUsage usage,
+    const gfx::ColorSpace& color_space) {
   DCHECK_LE(size.width(), max_texture_size_);
   DCHECK_LE(size.height(), max_texture_size_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // TODO(crbug.com/590317): We should not assume that all resources created by
   // ResourceProvider are GPU_READ_CPU_READ_WRITE. We should determine this
   // based on the current RasterBufferProvider's needs.
   GLenum target = type == RESOURCE_TYPE_GPU_MEMORY_BUFFER
                       ? GetImageTextureTarget(usage, format)
                       : GL_TEXTURE_2D;
 
   ResourceId id = next_id_++;
   Resource* resource =
       InsertResource(id, Resource(0, size, Resource::INTERNAL, target,
                                   GL_LINEAR, hint, type, format));
   resource->usage = usage;
   resource->allocated = false;
+  resource->color_space = color_space;
   return id;
 }
 
-ResourceId ResourceProvider::CreateBitmap(const gfx::Size& size) {
+ResourceId ResourceProvider::CreateBitmap(const gfx::Size& size,
+                                          const gfx::ColorSpace& color_space) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::unique_ptr<SharedBitmap> bitmap =
       shared_bitmap_manager_->AllocateSharedBitmap(size);
   uint8_t* pixels = bitmap->pixels();
   DCHECK(pixels);
 
   ResourceId id = next_id_++;
   Resource* resource = InsertResource(
       id,
       Resource(pixels, bitmap.release(), size, Resource::INTERNAL, GL_LINEAR));
   resource->allocated = true;
+  resource->color_space = color_space;
   return id;
 }
 
 ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox,
     std::unique_ptr<SingleReleaseCallbackImpl> release_callback_impl,
     bool read_lock_fences_enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
@@ skipping 1360 matching lines @@
 
     const int kImportance = 2;
     pmd->CreateSharedGlobalAllocatorDump(guid);
     pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
   }
 
   return true;
 }
 
 }  // namespace cc