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 441 matching lines @@
                  "read pixels");
     bool result = image->readPixels(decoded_info, decoded_pixels->data(),
                                     decoded_info.minRowBytes(), 0, 0,
                                     SkImage::kDisallow_CachingHint);
 
     if (!result) {
       decoded_pixels->Unlock();
       return nullptr;
     }
   }
+
+  // TODO(ccameron,msarett): Convert image to target color space.
+  // http://crbug.com/706613
+
   return base::MakeUnique<DecodedImage>(decoded_info, std::move(decoded_pixels),
                                         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 17 matching lines @@
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                  "SoftwareImageDecodeCache::GetSubrectImageDecode - "
                  "read pixels");
     bool result = decoded_draw_image.image()->readPixels(
         subrect_info, subrect_pixels->data(), subrect_info.minRowBytes(),
         key.src_rect().x(), key.src_rect().y(), SkImage::kDisallow_CachingHint);
     // We have a decoded image, and we're reading into already allocated memory.
     // This should never fail.
     DCHECK(result);
   }
+
+  // TODO(ccameron,msarett): Convert image to target color space.
+  // http://crbug.com/706613
+
   return base::WrapUnique(
       new DecodedImage(subrect_info, std::move(subrect_pixels),
                        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 23 matching lines @@
   DCHECK(key.filter_quality() == kHigh_SkFilterQuality ||
          key.filter_quality() == kMedium_SkFilterQuality);
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                  "SoftwareImageDecodeCache::ScaleImage - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result) << key.ToString();
   }
 
+  // TODO(ccameron,msarett): Convert image to target color space.
+  // http://crbug.com/706613
+
   return base::MakeUnique<DecodedImage>(
       scaled_info, std::move(scaled_pixels),
       SkSize::Make(-key.src_rect().x(), -key.src_rect().y()),
       next_tracing_id_.GetNext());
 }
 
 void SoftwareImageDecodeCache::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 229 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_));
   }
+  // Include the target color space in the hash regardless of scaling.
+  hash_ = base::HashInts(hash_, target_color_space.GetHash());
 }
 
 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