cc: ImageDecodes: Cleanup CanHandleImage

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 120 matching lines @@
   // we don't need to decode it or ref it).
   if (key.target_size().IsEmpty()) {
     *task = nullptr;
     return false;
   }
 
   // If we're not going to do a scale, we will just create a task to preroll the
   // image the first time we see it. This doesn't need to account for memory.
   // TODO(vmpstr): We can also lock the original sized image, in which case it
   // does require memory bookkeeping.
-  if (!CanHandleImage(key, image)) {
+  if (!CanHandleImage(key)) {
     base::AutoLock lock(lock_);
     if (prerolled_images_.count(key.image_id()) == 0) {
       scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
       if (!existing_task) {
         existing_task = make_scoped_refptr(
             new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
       }
       *task = existing_task;
     } else {
       *task = nullptr;
@@ skipping 65 matching lines @@
 }
 
 void SoftwareImageDecodeController::UnrefImage(const DrawImage& image) {
   // When we unref the image, there are several situations we need to consider:
   // 1. The ref did not reach 0, which means we have to keep the image locked.
   // 2. The ref reached 0, we should unlock it.
   //   2a. The image isn't in the locked cache because we didn't get to decode
   //       it yet (or failed to decode it).
   //   2b. Unlock the image but keep it in list.
   const ImageKey& key = ImageKey::FromDrawImage(image);
-  DCHECK(CanHandleImage(key, image));
+  DCHECK(CanHandleImage(key));
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::UnrefImage", "key",
                key.ToString());
 
   base::AutoLock lock(lock_);
   auto ref_count_it = decoded_images_ref_counts_.find(key);
   DCHECK(ref_count_it != decoded_images_ref_counts_.end());
 
   --ref_count_it->second;
   if (ref_count_it->second == 0) {
@@ skipping 10 matching lines @@
     DCHECK(decoded_image_it->second->is_locked());
     decoded_image_it->second->Unlock();
   }
   SanityCheckState(__LINE__, true);
 }
 
 void SoftwareImageDecodeController::DecodeImage(const ImageKey& key,
                                                 const DrawImage& image) {
   TRACE_EVENT1("cc", "SoftwareImageDecodeController::DecodeImage", "key",
                key.ToString());
-  if (!CanHandleImage(key, image)) {
+  if (!CanHandleImage(key)) {
     image.image()->preroll();
 
     base::AutoLock lock(lock_);
     prerolled_images_.insert(key.image_id());
     // Erase the pending task from the queue, since the task won't be doing
     // anything useful after this function terminates. Since we don't preroll
     // images twice, this is actually not necessary but it behaves similar to
     // the other code path: when this function finishes, the task isn't in the
     // pending_image_tasks_ list.
     pending_image_tasks_.erase(key);
@@ skipping 232 matching lines @@
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
                key.ToString());
   // 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))
+  if (!CanHandleImage(key))
     return DecodedDrawImage(draw_image.image(), draw_image.filter_quality());
 
   return GetDecodedImageForDrawInternal(key, draw_image);
 }
 
 DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
@@ skipping 84 matching lines @@
   return decoded_draw_image;
 }
 
 void SoftwareImageDecodeController::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {
   TRACE_EVENT1("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::DrawWithImageFinished", "key",
                ImageKey::FromDrawImage(image).ToString());
   ImageKey key = ImageKey::FromDrawImage(image);
-  if (!decoded_image.image() || !CanHandleImage(key, image))
+  if (!decoded_image.image() || !CanHandleImage(key))
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
   SanityCheckState(__LINE__, false);
 }
 
 void SoftwareImageDecodeController::RefAtRasterImage(const ImageKey& key) {
@@ skipping 46 matching lines @@
       DCHECK(decoded_images_ref_counts_.find(key) ==
              decoded_images_ref_counts_.end());
       at_raster_image_it->second->Unlock();
       decoded_images_.erase(image_it);
       decoded_images_.push_back(*at_raster_image_it);
     }
     at_raster_decoded_images_.erase(at_raster_image_it);
   }
 }
 
-bool SoftwareImageDecodeController::CanHandleImage(const ImageKey& key,
-                                                   const DrawImage& image) {
-  if (!CanHandleFilterQuality(key.filter_quality()))
-    return false;
-  return true;
-}
-
-bool SoftwareImageDecodeController::CanHandleFilterQuality(
-    SkFilterQuality filter_quality) {
-  // TODO(vmpstr): We need to start caching mipmaps for medium quality and
-  // caching the interpolated values from those. For now, we don't have this.
-  return filter_quality != kMedium_SkFilterQuality;
+bool SoftwareImageDecodeController::CanHandleImage(const ImageKey& key) {
+  // TODO(vmpstr): Start handling medium filter quality as well.
+  return key.filter_quality() != kMedium_SkFilterQuality;
 }
 
 void SoftwareImageDecodeController::ReduceCacheUsage() {
   TRACE_EVENT0("cc", "SoftwareImageDecodeController::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   size_t num_to_remove = (decoded_images_.size() > kMaxItemsInCache)
                              ? (decoded_images_.size() - kMaxItemsInCache)
                              : 0;
   for (auto it = decoded_images_.begin();
        num_to_remove != 0 && it != decoded_images_.end();) {
@@ skipping 215 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc