cc: Use SkCreateColorSpaceXformCanvas for color transforms

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 270 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_; }
+    // Will return the invalid color space unless
+    // |enable_color_correct_rasterization| is true.
+    const gfx::ColorSpace& color_space_for_raster() const {
+      return color_space_;
+    }
 
     const TextureMailbox& mailbox() const { return mailbox_; }
 
     void set_sync_token(const gpu::SyncToken& sync_token) {
       sync_token_ = sync_token;
       has_sync_token_ = true;
     }
 
     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 has_sync_token_;
     bool synchronized_;
     base::ThreadChecker thread_checker_;
-    sk_sp<SkColorSpace> sk_color_space_;
+    gfx::ColorSpace 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_; }
+    // Will return the invalid color space unless
+    // |enable_color_correct_rasterization| is true.
+    const gfx::ColorSpace& color_space_for_raster() const {
+      return color_space_;
+    }
 
    private:
     ResourceProvider* resource_provider_;
     ResourceId resource_id_;
     SkBitmap sk_bitmap_;
-    sk_sp<SkColorSpace> sk_color_space_;
+    gfx::ColorSpace 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_; }
+    // Will return the invalid color space unless
+    // |enable_color_correct_rasterization| is true.
+    const gfx::ColorSpace& color_space_for_raster() const {
+      return 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_;
+    gfx::ColorSpace color_space_;
     base::ThreadChecker thread_checker_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWriteLockGpuMemoryBuffer);
   };
 
   class Fence : public base::RefCounted<Fence> {
    public:
     Fence() {}
 
     virtual void Set() = 0;
@@ skipping 276 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 |settings_.enable_color_correct_rasterization| is false.
-  sk_sp<SkColorSpace> GetResourceSkColorSpace(const Resource* resource) const;
+  // Will return the invalid color space unless
+  // |enable_color_correct_rasterization| is true.
+  gfx::ColorSpace GetResourceColorSpaceForRaster(
+      const Resource* resource) const;
 
   // Holds const settings for the ResourceProvider. Never changed after init.
   struct Settings {
     Settings(ContextProvider* compositor_context_provider,
              bool delegated_sync_points_required,
              bool use_gpu_memory_buffer_resources,
              bool enable_color_correct_rasterization);
 
     int max_texture_size = 0;
     bool use_texture_storage_ext = false;
@@ skipping 32 matching lines @@
   // Set of resource Ids that would like to be notified about promotion hints.
   ResourceIdSet wants_promotion_hints_set_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ResourceProvider);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_