cc: Add color space to image decode caches

cc/tiles/software_image_decode_cache.h

 // Copyright 2016 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_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
 #define CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 28 matching lines @@
   static ImageDecodeCacheKey FromDrawImage(const DrawImage& image);
 
   ImageDecodeCacheKey(const ImageDecodeCacheKey& other);
 
   bool operator==(const ImageDecodeCacheKey& other) const {
     // The image_id always has to be the same. However, after that all original
     // decodes are the same, so if we can use the original decode, return true.
     // If not, then we have to compare every field.
     return image_id_ == other.image_id_ &&
            can_use_original_decode_ == other.can_use_original_decode_ &&
+           target_color_space_ == other.target_color_space_ &&
            (can_use_original_decode_ ||
             (src_rect_ == other.src_rect_ &&
              target_size_ == other.target_size_ &&
              filter_quality_ == other.filter_quality_));
   }
 
   bool operator!=(const ImageDecodeCacheKey& other) const {
     return !(*this == other);
   }
 
   uint32_t image_id() const { return image_id_; }
   SkFilterQuality filter_quality() const { return filter_quality_; }
   gfx::Rect src_rect() const { return src_rect_; }
   gfx::Size target_size() const { return target_size_; }
+  const gfx::ColorSpace& target_color_space() const {
+    return target_color_space_;
+  }
 
   bool can_use_original_decode() const { return can_use_original_decode_; }
   bool should_use_subrect() const { return should_use_subrect_; }
   size_t get_hash() const { return hash_; }
 
   // Helper to figure out how much memory the locked image represented by this
   // key would take.
   size_t locked_bytes() const {
     // TODO(vmpstr): Handle formats other than RGBA.
     base::CheckedNumeric<size_t> result = 4;
     result *= target_size_.width();
     result *= target_size_.height();
     return result.ValueOrDefault(std::numeric_limits<size_t>::max());
   }
 
   std::string ToString() const;
 
  private:
   ImageDecodeCacheKey(uint32_t image_id,
                       const gfx::Rect& src_rect,
                       const gfx::Size& size,
+                      const gfx::ColorSpace& target_color_space,
                       SkFilterQuality filter_quality,
                       bool can_use_original_decode,
                       bool should_use_subrect);
 
   uint32_t image_id_;
   gfx::Rect src_rect_;
   gfx::Size target_size_;
+  gfx::ColorSpace target_color_space_;
   SkFilterQuality filter_quality_;
   bool can_use_original_decode_;
   bool should_use_subrect_;
   size_t hash_;
 };
 
 // Hash function for the above ImageDecodeCacheKey.
 struct ImageDecodeCacheKeyHash {
   size_t operator()(const ImageDecodeCacheKey& key) const {
     return key.get_hash();
@@ skipping 208 matching lines @@
   ResourceFormat format_;
   size_t max_items_in_cache_;
 
   // Used to uniquely identify DecodedImages for memory traces.
   base::AtomicSequenceNumber next_tracing_id_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_