cc: Add color space to image decode caches

cc/tiles/software_image_decode_cache.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/tiles/software_image_decode_cache.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 593 matching lines @@
                                         SkSize::Make(0, 0),
                                         next_tracing_id_.GetNext());
 }
 
 std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
 SoftwareImageDecodeCache::GetSubrectImageDecode(const ImageKey& key,
                                                 sk_sp<const SkImage> image) {
   // Construct a key to use in GetDecodedImageForDrawInternal().
   // This allows us to reuse an image in any cache if available.
   gfx::Rect full_image_rect(image->width(), image->height());
-  DrawImage original_size_draw_image(std::move(image),
-                                     gfx::RectToSkIRect(full_image_rect),
-                                     kNone_SkFilterQuality, SkMatrix::I());
+  DrawImage original_size_draw_image(
+      std::move(image), gfx::RectToSkIRect(full_image_rect),
+      kNone_SkFilterQuality, SkMatrix::I(), key.target_color_space());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_decode())
       << original_size_key.ToString();
   DCHECK(full_image_rect.size() == original_size_key.target_size());
 
   auto decoded_draw_image = GetDecodedImageForDrawInternal(
       original_size_key, original_size_draw_image);
   AutoDrawWithImageFinished auto_finish_draw(this, original_size_draw_image,
@@ skipping 33 matching lines @@
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y()),
                        next_tracing_id_.GetNext()));
 }
 
 std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
 SoftwareImageDecodeCache::GetScaledImageDecode(const ImageKey& key,
                                                sk_sp<const SkImage> image) {
   // Construct a key to use in GetDecodedImageForDrawInternal().
   // This allows us to reuse an image in any cache if available.
   gfx::Rect full_image_rect(image->width(), image->height());
-  DrawImage original_size_draw_image(std::move(image),
-                                     gfx::RectToSkIRect(full_image_rect),
-                                     kNone_SkFilterQuality, SkMatrix::I());
+  DrawImage original_size_draw_image(
+      std::move(image), gfx::RectToSkIRect(full_image_rect),
+      kNone_SkFilterQuality, SkMatrix::I(), key.target_color_space());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_decode())
       << original_size_key.ToString();
   DCHECK(full_image_rect.size() == original_size_key.target_size());
 
   auto decoded_draw_image = GetDecodedImageForDrawInternal(
       original_size_key, original_size_draw_image);
   AutoDrawWithImageFinished auto_finish_draw(this, original_size_draw_image,
@@ skipping 273 matching lines @@
   // we're enlarging the image in both dimensions.
   if (quality == kMedium_SkFilterQuality) {
     if (!image.matrix_is_decomposable() ||
         (scale.width() >= 1.f && scale.height() >= 1.f)) {
       quality = kLow_SkFilterQuality;
     }
   }
 
   bool can_use_original_decode =
       quality == kLow_SkFilterQuality || quality == kNone_SkFilterQuality;
+
+  // Disallow using the original decode if it does not match the target color
+  // space.
+  if (image.target_color_space().IsValid()) {

[vmpstr, 2017/04/04 01:16:43]

Hmm, right now the check whether we can use the original decode is only used for
sizing (ie, the scale adjustment is 1.f, 1.f if we can use it, which means that
the image is passed from here to skia without any additional scales. 

I _think_ this is OK, since the calculation of the scale adjustment should
result in 0 anyway if we have a low/none filter quality, but I was wondering why
this check?

[ccameron, 2017/04/04 06:41:10]

I renamed can_use_original_decode to can_use_original_size_decode, since this
really just encodes information about size, and I removed the color space bit
here (but added it to the hash).

+    sk_sp<SkColorSpace> target_sk_color_space =
+        image.target_color_space().ToSkColorSpace();
+    can_use_original_decode &= SkColorSpace::Equals(
+        image.image()->colorSpace(), target_sk_color_space.get());
+  }
+
   bool should_use_subrect = false;
   if (can_use_original_decode &&
       (image.image()->width() >= kMinDimensionToSubrect ||
        image.image()->height() >= kMinDimensionToSubrect)) {
     base::CheckedNumeric<size_t> checked_original_size = 4u;
     checked_original_size *= image.image()->width();
     checked_original_size *= image.image()->height();
     size_t original_size = checked_original_size.ValueOrDefault(
         std::numeric_limits<size_t>::max());
 
@@ skipping 21 matching lines @@
   }
 
   if (quality == kMedium_SkFilterQuality && !target_size.IsEmpty()) {
     SkSize mip_target_size =
         MipMapUtil::GetScaleAdjustmentForSize(src_rect.size(), target_size);
     target_size.set_width(src_rect.width() * mip_target_size.width());
     target_size.set_height(src_rect.height() * mip_target_size.height());
   }
 
   return ImageDecodeCacheKey(image.image()->uniqueID(), src_rect, target_size,
-                             quality, can_use_original_decode,
-                             should_use_subrect);
+                             image.target_color_space(), quality,
+                             can_use_original_decode, should_use_subrect);
 }
 
-ImageDecodeCacheKey::ImageDecodeCacheKey(uint32_t image_id,
-                                         const gfx::Rect& src_rect,
-                                         const gfx::Size& target_size,
-                                         SkFilterQuality filter_quality,
-                                         bool can_use_original_decode,
-                                         bool should_use_subrect)
+ImageDecodeCacheKey::ImageDecodeCacheKey(
+    uint32_t image_id,
+    const gfx::Rect& src_rect,
+    const gfx::Size& target_size,
+    const gfx::ColorSpace& target_color_space,
+    SkFilterQuality filter_quality,
+    bool can_use_original_decode,
+    bool should_use_subrect)
     : image_id_(image_id),
       src_rect_(src_rect),
       target_size_(target_size),
+      target_color_space_(target_color_space),
       filter_quality_(filter_quality),
       can_use_original_decode_(can_use_original_decode),
       should_use_subrect_(should_use_subrect) {
   if (can_use_original_decode_) {
     hash_ = std::hash<uint32_t>()(image_id_);
   } else {
     // TODO(vmpstr): This is a mess. Maybe it's faster to just search the vector

[vmpstr, 2017/04/04 01:16:43]

You probably need to add to this mess, since otherwise every pair of images that
only differ by color space will result in a hash collision.

[ccameron, 2017/04/04 06:41:10]

Added it to both sides of the if(), cause can_use_original_decode (now) is just
about size.

     // always (forwards or backwards to account for LRU).
     uint64_t src_rect_hash = base::HashInts(
         static_cast<uint64_t>(base::HashInts(src_rect_.x(), src_rect_.y())),
         static_cast<uint64_t>(
             base::HashInts(src_rect_.width(), src_rect_.height())));
 
     uint64_t target_size_hash =
         base::HashInts(target_size_.width(), target_size_.height());
 
     hash_ = base::HashInts(base::HashInts(src_rect_hash, target_size_hash),
                            base::HashInts(image_id_, filter_quality_));
   }
 }
 
 ImageDecodeCacheKey::ImageDecodeCacheKey(const ImageDecodeCacheKey& other) =
     default;
 
 std::string ImageDecodeCacheKey::ToString() const {
   std::ostringstream str;
   str << "id[" << image_id_ << "] src_rect[" << src_rect_.x() << ","
       << src_rect_.y() << " " << src_rect_.width() << "x" << src_rect_.height()
       << "] target_size[" << target_size_.width() << "x"
-      << target_size_.height() << "] filter_quality[" << filter_quality_
+      << target_size_.height() << "] target_color_space"
+      << target_color_space_.ToString() << " filter_quality[" << filter_quality_
       << "] can_use_original_decode [" << can_use_original_decode_
       << "] should_use_subrect [" << should_use_subrect_ << "] hash [" << hash_
       << "]";
   return str.str();
 }
 
 // DecodedImage
 SoftwareImageDecodeCache::DecodedImage::DecodedImage(
     const SkImageInfo& info,
     std::unique_ptr<base::DiscardableMemory> memory,
@@ skipping 117 matching lines @@
     }
   }
 }
 
 void SoftwareImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   ReduceCacheUsageUntilWithinLimit(0);
 }
 
 }  // namespace cc