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 120 matching lines @@
   DrawImage image_;
   SoftwareImageDecodeCache::DecodeTaskType task_type_;
   const ImageDecodeCache::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 SkSize GetScaleAdjustment(const ImageDecodeCacheKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
   // is identity.
-  if (key.can_use_original_decode() || key.should_use_subrect()) {
+  if (key.can_use_original_size_decode() || key.should_use_subrect()) {
     return SkSize::Make(1.f, 1.f);
   } else if (key.filter_quality() == kMedium_SkFilterQuality) {
     return MipMapUtil::GetScaleAdjustmentForSize(key.src_rect().size(),
                                                  key.target_size());
   } else {
     float x_scale =
         key.target_size().width() / static_cast<float>(key.src_rect().width());
     float y_scale = key.target_size().height() /
                     static_cast<float>(key.src_rect().height());
     return SkSize::Make(x_scale, y_scale);
@@ skipping 452 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())
+  DCHECK(original_size_key.can_use_original_size_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,
                                              decoded_draw_image);
   if (!decoded_draw_image.image())
     return nullptr;
 
@@ skipping 29 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())
+  DCHECK(original_size_key.can_use_original_size_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,
                                              decoded_draw_image);
   if (!decoded_draw_image.image())
     return nullptr;
 
@@ skipping 267 matching lines @@
 
   // Drop from medium to low if the matrix we applied wasn't decomposable or if
   // 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 =
+  bool can_use_original_size_decode =
       quality == kLow_SkFilterQuality || quality == kNone_SkFilterQuality;
+
   bool should_use_subrect = false;
-  if (can_use_original_decode &&
+  if (can_use_original_size_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());
 
     base::CheckedNumeric<size_t> checked_src_rect_size = 4u;
     checked_src_rect_size *= src_rect.width();
     checked_src_rect_size *= src_rect.height();
     size_t src_rect_size = checked_src_rect_size.ValueOrDefault(
         std::numeric_limits<size_t>::max());
     if (original_size > kMemoryThresholdToSubrect &&
         src_rect_size <= original_size * kMemoryRatioToSubrect) {
       should_use_subrect = true;
-      can_use_original_decode = false;
+      can_use_original_size_decode = false;
     }
   }
 
   // If we're going to use the original decode, then the target size should be
   // the full image size, since that will allow for proper memory accounting.
   // Note we skip the decode if the target size is empty altogether, so don't
   // update the target size in that case.
   if (!target_size.IsEmpty()) {
     if (should_use_subrect)
       target_size = src_rect.size();
-    else if (can_use_original_decode)
+    else if (can_use_original_size_decode)
       target_size = gfx::Size(image.image()->width(), image.image()->height());
   }
 
   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_size_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_size_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),
+      can_use_original_size_decode_(can_use_original_size_decode),
       should_use_subrect_(should_use_subrect) {
-  if (can_use_original_decode_) {
+  if (can_use_original_size_decode_) {
     hash_ = std::hash<uint32_t>()(image_id_);
   } else {
     // TODO(vmpstr): This is a mess. Maybe it's faster to just search the vector
     // 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_));
   }
+  hash_ = base::HashInts(hash_, target_color_space.GetHash());

[vmpstr, 2017/04/04 17:30:08]

leave a comment here please

[ccameron, 2017/04/04 17:42:03]

Sure -- if I leave it in, that is...

If I make I'll take a stab at making target_color_space be an
sk_sp<SkColorSpace> (in which case it won't enter the hash, cause it has no hash
function).

 }
 
 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_
-      << "] can_use_original_decode [" << can_use_original_decode_
+      << target_size_.height() << "] target_color_space"
+      << target_color_space_.ToString() << " filter_quality[" << filter_quality_
+      << "] can_use_original_size_decode [" << can_use_original_size_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,
     const SkSize& src_rect_offset,
@@ skipping 116 matching lines @@
     }
   }
 }
 
 void SoftwareImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   ReduceCacheUsageUntilWithinLimit(0);
 }
 
 }  // namespace cc