cc: Populate SkColorSpace for raster from resource gfx::ColorSpace

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 78 matching lines @@
 
   ResourceProvider(
       ContextProvider* compositor_context_provider,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       BlockingTaskRunner* blocking_main_thread_task_runner,
       int highp_threshold_min,
       size_t id_allocation_chunk_size,
       bool delegated_sync_points_required,
       bool use_gpu_memory_buffer_resources,
+      bool enable_color_correct_rendering,
       const BufferToTextureTargetMap& buffer_to_texture_target_map);
   ~ResourceProvider() override;
 
   void Initialize();
 
   void DidLoseOutputSurface() { lost_output_surface_ = true; }
 
   int max_texture_size() const { return max_texture_size_; }
   ResourceFormat best_texture_format() const { return best_texture_format_; }
   ResourceFormat best_render_buffer_format() const {
@@ skipping 159 matching lines @@
    public:
     ScopedWriteLockGL(ResourceProvider* resource_provider,
                       ResourceId resource_id,
                       bool create_mailbox);
     ~ScopedWriteLockGL();
 
     unsigned texture_id() const { return texture_id_; }
     GLenum target() const { return target_; }
     ResourceFormat format() const { return format_; }
     const gfx::Size& size() const { return size_; }
+    sk_sp<SkColorSpace> sk_color_space() const { return sk_color_space_; }
 
     const TextureMailbox& mailbox() const { return mailbox_; }
 
     void set_sync_token(const gpu::SyncToken& sync_token) {
       sync_token_ = sync_token;
     }
 
     void set_synchronized(bool synchronized) { synchronized_ = synchronized; }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
     unsigned texture_id_;
     GLenum target_;
     ResourceFormat format_;
     gfx::Size size_;
     TextureMailbox mailbox_;
     gpu::SyncToken sync_token_;
     bool synchronized_;
     base::ThreadChecker thread_checker_;
+    sk_sp<SkColorSpace> sk_color_space_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGL);
   };
 
   class CC_EXPORT ScopedTextureProvider {
    public:
     ScopedTextureProvider(gpu::gles2::GLES2Interface* gl,
                           ScopedWriteLockGL* resource_lock,
                           bool use_mailbox);
     ~ScopedTextureProvider();
@@ skipping 67 matching lines @@
   };
 
   class CC_EXPORT ScopedWriteLockSoftware {
    public:
     ScopedWriteLockSoftware(ResourceProvider* resource_provider,
                             ResourceId resource_id);
     ~ScopedWriteLockSoftware();
 
     SkBitmap& sk_bitmap() { return sk_bitmap_; }
     bool valid() const { return !!sk_bitmap_.getPixels(); }
+    sk_sp<SkColorSpace> sk_color_space() const { return sk_color_space_; }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
     SkBitmap sk_bitmap_;
+    sk_sp<SkColorSpace> sk_color_space_;
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockSoftware);
   };
 
   class CC_EXPORT ScopedWriteLockGpuMemoryBuffer {
    public:
     ScopedWriteLockGpuMemoryBuffer(ResourceProvider* resource_provider,
                                    ResourceId resource_id);
     ~ScopedWriteLockGpuMemoryBuffer();
-
     gfx::GpuMemoryBuffer* GetGpuMemoryBuffer();
+    sk_sp<SkColorSpace> sk_color_space() const { return sk_color_space_; }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
     ResourceFormat format_;
     gfx::BufferUsage usage_;
     gfx::Size size_;
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer_;
+    sk_sp<SkColorSpace> sk_color_space_;
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
   };
 
   class Fence : public base::RefCounted<Fence> {
    public:
     Fence() {}
 
     virtual void Set() = 0;
@@ skipping 208 matching lines @@
                              const gfx::ColorSpace& color_space);
   ResourceId CreateBitmap(const gfx::Size& size,
                           const gfx::ColorSpace& color_space);
   Resource* InsertResource(ResourceId id, Resource resource);
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
   Resource* LockForWrite(ResourceId id);
   void UnlockForWrite(Resource* resource);
 
-  static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
-                                           const Resource* resource);
+  void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
+                                    const Resource* resource);
 
   void CreateMailboxAndBindResource(gpu::gles2::GLES2Interface* gl,
                                     Resource* resource);
 
   void TransferResource(Resource* source,
                         ResourceId id,
                         TransferableResource* resource);
   enum DeleteStyle {
     NORMAL,
     FOR_SHUTDOWN,
@@ skipping 10 matching lines @@
   void BindImageForSampling(Resource* resource);
   // Binds the given GL resource to a texture target for sampling using the
   // specified filter for both minification and magnification. Returns the
   // texture target used. The resource must be locked for reading.
   GLenum BindForSampling(ResourceId resource_id, GLenum unit, GLenum filter);
 
   // Returns null if we do not have a ContextProvider.
   gpu::gles2::GLES2Interface* ContextGL() const;
   bool IsGLContextLost() const;
 
+  // Returns null if |enable_color_correct_rendering_| is false.
+  sk_sp<SkColorSpace> GetResourceSkColorSpace(const Resource* resource) const;
+
   ContextProvider* compositor_context_provider_;
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   BlockingTaskRunner* blocking_main_thread_task_runner_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
   int next_child_;
   ChildMap children_;
 
   const bool delegated_sync_points_required_;
 
   ResourceType default_resource_type_;
   bool use_texture_storage_ext_;
   bool use_texture_format_bgra_;
   bool use_texture_usage_hint_;
   bool use_compressed_texture_etc1_;
   ResourceFormat yuv_resource_format_;
   ResourceFormat yuv_highbit_resource_format_;
   int max_texture_size_;
   ResourceFormat best_texture_format_;
   ResourceFormat best_render_buffer_format_;
+  const bool enable_color_correct_rendering_ = false;
 
   base::ThreadChecker thread_checker_;
 
   scoped_refptr<Fence> current_read_lock_fence_;
 
   const size_t id_allocation_chunk_size_;
   std::unique_ptr<IdAllocator> texture_id_allocator_;
   std::unique_ptr<IdAllocator> buffer_id_allocator_;
 
   bool use_sync_query_;
   BufferToTextureTargetMap buffer_to_texture_target_map_;
 
   // A process-unique ID used for disambiguating memory dumps from different
   // resource providers.
   int tracing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_