cc: Keep PaintImage in DrawImage.

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 427 matching lines @@
                "SoftwareImageDecodeCache::DecodeImageInternal", "key",
                key.ToString());
   sk_sp<const SkImage> image = draw_image.image();
   if (!image)
     return nullptr;
 
   switch (key.filter_quality()) {
     case kNone_SkFilterQuality:
     case kLow_SkFilterQuality:
       if (key.should_use_subrect())
-        return GetSubrectImageDecode(key, std::move(image));
+        return GetSubrectImageDecode(key, draw_image.paint_image());
       return GetOriginalSizeImageDecode(key, std::move(image));
     case kMedium_SkFilterQuality:
     case kHigh_SkFilterQuality:
-      return GetScaledImageDecode(key, std::move(image));
+      return GetScaledImageDecode(key, draw_image.paint_image());
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 DecodedDrawImage SoftwareImageDecodeCache::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
@@ skipping 141 matching lines @@
   }
 
   return base::MakeUnique<DecodedImage>(
       decoded_info.makeColorSpace(target_color_space),
       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) {
+                                                PaintImage 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());
+  gfx::Rect full_image_rect(image.sk_image()->width(),
+                            image.sk_image()->height());
   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);
   sk_sp<SkColorSpace> target_color_space =
       key.target_color_space().ToSkColorSpace();
 
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_size_decode())
@@ skipping 39 matching lines @@
 
   return base::WrapUnique(
       new DecodedImage(subrect_info.makeColorSpace(target_color_space),
                        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) {
+                                               PaintImage 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());
+  gfx::Rect full_image_rect(image.sk_image()->width(),
+                            image.sk_image()->height());
   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);
   sk_sp<SkColorSpace> target_color_space =
       key.target_color_space().ToSkColorSpace();
 
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_size_decode())
@@ skipping 486 matching lines @@
     }
   }
 }
 
 void SoftwareImageDecodeCache::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   ReduceCacheUsageUntilWithinLimit(0);
 }
 
 }  // namespace cc