cc: ImageDecodes: Always use original decode for bilerp.

cc/tiles/software_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/software_image_decode_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
@@ skipping 65 matching lines @@
 template <typename Type>
 typename std::deque<Type>::iterator FindImage(
     std::deque<Type>* collection,
     const ImageDecodeControllerKey& key) {
   return std::find_if(collection->begin(), collection->end(),
                       [key](const Type& image) { return image.first == key; });
 }
 
 SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
-  // is identity. Note that we still might have extracted a subrect, so
-  // can_use_original_decode is not a sufficient check.
-  if (key.filter_quality() == kLow_SkFilterQuality ||
-      key.filter_quality() == kNone_SkFilterQuality) {
+  // is identity.
+  if (key.can_use_original_decode())
     return SkSize::Make(1.f, 1.f);
-  }
 
   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);
 }
 
 SkFilterQuality GetDecodedFilterQuality(const ImageDecodeControllerKey& key) {
   return std::min(key.filter_quality(), kLow_SkFilterQuality);
@@ skipping 291 matching lines @@
   if (!decoded_draw_image.image()) {
     DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
     return nullptr;
   }
 
   scoped_ptr<uint8_t[]> decoded_subrect_pixels;
   SkPixmap decoded_pixmap;
   bool result;
   if (key.src_rect() == full_image_rect) {
     result = decoded_draw_image.image()->peekPixels(&decoded_pixmap);
-  } else if (key.filter_quality() != kNone_SkFilterQuality &&
-             key.filter_quality() != kLow_SkFilterQuality) {
+  } else {
+    // TODO(vmpstr): We don't need to allocate memory here, we can use some
+    // pointer math to get the subrect from the original. This is possible
+    // because we know the original can peek pixels.
     SkImageInfo decoded_info = SkImageInfo::MakeN32Premul(
         key.src_rect().width(), key.src_rect().height());
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "SoftwareImageDecodeController::DecodeImageInternal - allocate "
           "decoded pixels");
       decoded_subrect_pixels.reset(
           new uint8_t[decoded_info.minRowBytes() * decoded_info.height()]);
     }
     {
       TRACE_EVENT0(
           "disabled-by-default-cc.debug",
           "SoftwareImageDecodeController::DecodeImageInternal - read pixels");
       result =
           image->readPixels(decoded_info, decoded_subrect_pixels.get(),
                             decoded_info.minRowBytes(), key.src_rect().x(),
                             key.src_rect().y(), SkImage::kDisallow_CachingHint);
     }
     decoded_pixmap = SkPixmap(decoded_info, decoded_subrect_pixels.get(),
                               decoded_info.minRowBytes());
-  } else {
-    // In a low and none filter quality cases if we need a subrect, we need to
-    // extract it but then we don't need to scale it.
-    SkImageInfo decoded_info = SkImageInfo::MakeN32Premul(
-        key.src_rect().width(), key.src_rect().height());
-    scoped_ptr<base::DiscardableMemory> discardable_subrect_pixels;
-    {
-      TRACE_EVENT0(
-          "disabled-by-default-cc.debug",
-          "SoftwareImageDecodeController::DecodeImageInternal - allocate "
-          "discardable subrect pixels");
-      discardable_subrect_pixels =
-          base::DiscardableMemoryAllocator::GetInstance()
-              ->AllocateLockedDiscardableMemory(decoded_info.minRowBytes() *
-                                                decoded_info.height());
-    }
-    {
-      TRACE_EVENT0("disabled-by-default-cc.debug",
-                   "SoftwareImageDecodeController::DecodeImageInternal - read "
-                   "subrect pixels");
-      result =
-          image->readPixels(decoded_info, discardable_subrect_pixels->data(),
-                            decoded_info.minRowBytes(), key.src_rect().x(),
-                            key.src_rect().y(), SkImage::kDisallow_CachingHint);
-    }
-    DCHECK(result);
-    DrawWithImageFinished(original_size_draw_image, decoded_draw_image);
-    return make_scoped_refptr(new DecodedImage(
-        decoded_info, std::move(discardable_subrect_pixels),
-        SkSize::Make(-key.src_rect().x(), -key.src_rect().y())));
   }
 
   // Since the decoded_draw_image has locked memory, it should always succeed on
   // both peekPixels and readPixels.
   DCHECK(result);
 
   // Now we have a decoded_pixmap which represents the src_rect at the
   // original
   // scale. All we need to do is scale it.
   DCHECK(!key.target_size().IsEmpty());
@@ skipping 322 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;
     }
   }
 
-  gfx::Size full_image_size(image.image()->width(), image.image()->height());
-  gfx::Rect full_image_rect(full_image_size);
-  bool scale_needs_caching =
-      quality != kLow_SkFilterQuality && quality != kNone_SkFilterQuality;
-  bool is_full_image_rect = full_image_rect == src_rect;
-  bool scale_is_required = src_rect.width() != target_size.width() ||
-                           src_rect.height() != target_size.height();
   bool can_use_original_decode =
-      !scale_needs_caching && (is_full_image_rect || !scale_is_required);
+      quality == kLow_SkFilterQuality || quality == kNone_SkFilterQuality;
+
   // 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 (can_use_original_decode && !target_size.IsEmpty())
-    target_size = full_image_size;
+    target_size = gfx::Size(image.image()->width(), image.image()->height());
 
   return ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
                                   target_size, quality,
                                   can_use_original_decode);
 }
 
 ImageDecodeControllerKey::ImageDecodeControllerKey(
     uint32_t image_id,
     const gfx::Rect& src_rect,
     const gfx::Size& target_size,
@@ skipping 88 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc