Reland: cc: Imagedecodes: Clip the src_rect to the image rect.

cc/tiles/image_decode_controller.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/image_decode_controller.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
@@ skipping 353 matching lines @@
       new DecodedImage(scaled_info, std::move(scaled_pixels),
                        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
 }
 
 DecodedDrawImage ImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "ImageDecodeController::GetDecodedImageAndRef", "key",
                key.ToString());
-  if (!CanHandleImage(key, draw_image))
-    return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
-
   // If the target size is empty, we can skip this image draw.
   if (key.target_size().IsEmpty())
     return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
 
+  if (!CanHandleImage(key, draw_image))
+    return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
+
   base::AutoLock lock(lock_);
   auto decoded_images_it = FindImage(&decoded_images_, key);
   // If we found the image and it's locked, then return it. If it's not locked,
   // erase it from the cache since it might be put into the at-raster cache.
   scoped_refptr<DecodedImage> decoded_image;
   if (decoded_images_it != decoded_images_.end()) {
     decoded_image = decoded_images_it->second;
     if (decoded_image->is_locked()) {
       RefImage(key);
       SanityCheckState(__LINE__, true);
@@ skipping 241 matching lines @@
   DCHECK_GE(budget.AvailableMemoryBytes(),
             locked_images_budget_.AvailableMemoryBytes())
       << line;
 #endif  // DCHECK_IS_ON()
 }
 
 // ImageDecodeControllerKey
 ImageDecodeControllerKey ImageDecodeControllerKey::FromDrawImage(
     const DrawImage& image) {
   const SkSize& scale = image.scale();
+  // If the src_rect falls outside of the image, we need to clip it since
+  // otherwise we might end up with uninitialized memory in the decode process.
+  // Note that the scale is still unchanged and the target size is now a
+  // function of the new src_rect.
+  gfx::Rect src_rect = gfx::IntersectRects(
+      gfx::SkIRectToRect(image.src_rect()),
+      gfx::Rect(image.image()->width(), image.image()->height()));
+
   gfx::Size target_size(
-      SkScalarRoundToInt(std::abs(image.src_rect().width() * scale.width())),
-      SkScalarRoundToInt(std::abs(image.src_rect().height() * scale.height())));
+      SkScalarRoundToInt(std::abs(src_rect.width() * scale.width())),
+      SkScalarRoundToInt(std::abs(src_rect.height() * scale.height())));
 
   // Start with the quality that was requested.
   SkFilterQuality quality = image.filter_quality();
 
   // If we're not going to do a scale, we can use low filter quality. Note that
   // checking if the sizes are the same is better than checking if scale is 1.f,
   // because even non-1 scale can result in the same (rounded) width/height.
-  if (target_size.width() == image.src_rect().width() &&
-      target_size.height() == image.src_rect().height()) {
+  if (target_size.width() == src_rect.width() &&
+      target_size.height() == src_rect.height()) {
     quality = std::min(quality, kLow_SkFilterQuality);
   }
 
   // Drop from high to medium if the image has perspective applied, the matrix
   // we applied wasn't decomposable, or if the scaled image will be too large.
   if (quality == kHigh_SkFilterQuality) {
     if (image.matrix_has_perspective() || !image.matrix_is_decomposable()) {
       quality = kMedium_SkFilterQuality;
     } else {
       base::CheckedNumeric<size_t> size = 4u;
       size *= target_size.width();
       size *= target_size.height();
       if (size.ValueOrDefault(std::numeric_limits<size_t>::max()) >
           kMaxHighQualityImageSizeBytes) {
         quality = kMedium_SkFilterQuality;
       }
     }
   }
 
   // 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;
     }
   }
 
-  return ImageDecodeControllerKey(image.image()->uniqueID(),
-                                  gfx::SkIRectToRect(image.src_rect()),
+  return ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
                                   target_size, quality);
 }
 
 ImageDecodeControllerKey::ImageDecodeControllerKey(
     uint32_t image_id,
     const gfx::Rect& src_rect,
     const gfx::Size& target_size,
     SkFilterQuality filter_quality)
     : image_id_(image_id),
       src_rect_(src_rect),
@@ skipping 62 matching lines @@
 
 void ImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t ImageDecodeController::MemoryBudget::GetCurrentUsageSafe() const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc