cc: Add color space to image decode caches

cc/paint/discardable_image_map.cc

 // Copyright 2015 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/paint/discardable_image_map.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 197 matching lines @@
     // this here by outsetting the image rect by 1. Note that this only affects
     // queries into the rtree, which will now return images that only touch the
     // bounds of the query rect.
     //
     // Note that it's not sufficient for us to inset the device clip bounds at
     // raster time, since we might be sending a larger-than-one-item display
     // item to skia, which means that skia will internally determine whether to
     // raster the picture (using device clip bounds that are outset).
     image_rect.Inset(-1, -1);
 
+    // The true target color space will be assigned when it is known, in
+    // GetDiscardableImagesInRect.
+    gfx::ColorSpace target_color_space;
+
     (*image_id_to_rect_)[image->uniqueID()].Union(image_rect);
-    image_set_->push_back(std::make_pair(
-        DrawImage(std::move(image), src_irect, filter_quality, matrix),
-        image_rect));
+    image_set_->push_back(
+        std::make_pair(DrawImage(std::move(image), src_irect, filter_quality,
+                                 matrix, target_color_space),
+                       image_rect));
   }
 
   // Currently this function only handles extracting images from SkImageShaders
   // embedded in SkPaints. Other embedded image cases, such as SkPictures,
   // are not yet handled.
   void AddPaintImage(const SkRect& rect, const SkPaint& paint) {
     SkShader* shader = paint.getShader();
     if (shader) {
       SkMatrix matrix;
       SkShader::TileMode xy[2];
@@ skipping 32 matching lines @@
 void DiscardableImageMap::EndGeneratingMetadata() {
   images_rtree_.Build(all_images_,
                       [](const std::pair<DrawImage, gfx::Rect>& image) {
                         return image.second;
                       });
 }
 
 void DiscardableImageMap::GetDiscardableImagesInRect(
     const gfx::Rect& rect,
     float contents_scale,
+    const gfx::ColorSpace& target_color_space,
     std::vector<DrawImage>* images) const {
   std::vector<size_t> indices;
   images_rtree_.Search(rect, &indices);
-  for (size_t index : indices)
-    images->push_back(all_images_[index].first.ApplyScale(contents_scale));
+  for (size_t index : indices) {
+    images->push_back(all_images_[index]
+                          .first.ApplyScale(contents_scale)
+                          .ApplyTargetColorSpace(target_color_space));
+  }
 }
 
 gfx::Rect DiscardableImageMap::GetRectForImage(ImageId image_id) const {
   const auto& it = image_id_to_rect_.find(image_id);
   return it == image_id_to_rect_.end() ? gfx::Rect() : it->second;
 }
 
 DiscardableImageMap::ScopedMetadataGenerator::ScopedMetadataGenerator(
     DiscardableImageMap* image_map,
     const gfx::Size& bounds)
     : image_map_(image_map),
       metadata_canvas_(image_map->BeginGeneratingMetadata(bounds)) {}
 
 DiscardableImageMap::ScopedMetadataGenerator::~ScopedMetadataGenerator() {
   image_map_->EndGeneratingMetadata();
 }
 
 }  // namespace cc