cc: Rename ImageDecodeController to ImageDecodeCache.

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_controller.h"
+#include "cc/tiles/software_image_decode_cache.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
@@ skipping 34 matching lines @@
 // don't need to scale the image, consider caching only the needed subrect.
 // The second part that much be true is that we cache only the needed subrect if
 // the total size needed for the subrect is at most kMemoryRatioToSubrect *
 // (size needed for the full original image).
 const size_t kMemoryThresholdToSubrect = 64 * 1024 * 1024;
 const float kMemoryRatioToSubrect = 0.5f;
 
 class AutoRemoveKeyFromTaskMap {
  public:
   AutoRemoveKeyFromTaskMap(
-      std::unordered_map<SoftwareImageDecodeController::ImageKey,
+      std::unordered_map<SoftwareImageDecodeCache::ImageKey,
                          scoped_refptr<TileTask>,
-                         SoftwareImageDecodeController::ImageKeyHash>* task_map,
-      const SoftwareImageDecodeController::ImageKey& key)
+                         SoftwareImageDecodeCache::ImageKeyHash>* task_map,
+      const SoftwareImageDecodeCache::ImageKey& key)
       : task_map_(task_map), key_(key) {}
   ~AutoRemoveKeyFromTaskMap() { task_map_->erase(key_); }
 
  private:
-  std::unordered_map<SoftwareImageDecodeController::ImageKey,
+  std::unordered_map<SoftwareImageDecodeCache::ImageKey,
                      scoped_refptr<TileTask>,
-                     SoftwareImageDecodeController::ImageKeyHash>* task_map_;
-  const SoftwareImageDecodeController::ImageKey& key_;
+                     SoftwareImageDecodeCache::ImageKeyHash>* task_map_;
+  const SoftwareImageDecodeCache::ImageKey& key_;
 };
 
 class AutoDrawWithImageFinished {
  public:
-  AutoDrawWithImageFinished(SoftwareImageDecodeController* controller,
+  AutoDrawWithImageFinished(SoftwareImageDecodeCache* cache,
                             const DrawImage& draw_image,
                             const DecodedDrawImage& decoded_draw_image)
-      : controller_(controller),
+      : cache_(cache),
         draw_image_(draw_image),
         decoded_draw_image_(decoded_draw_image) {}
   ~AutoDrawWithImageFinished() {
-    controller_->DrawWithImageFinished(draw_image_, decoded_draw_image_);
+    cache_->DrawWithImageFinished(draw_image_, decoded_draw_image_);
   }
 
  private:
-  SoftwareImageDecodeController* controller_;
+  SoftwareImageDecodeCache* cache_;
   const DrawImage& draw_image_;
   const DecodedDrawImage& decoded_draw_image_;
 };
 
 class ImageDecodeTaskImpl : public TileTask {
  public:
-  ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
-                      const SoftwareImageDecodeController::ImageKey& image_key,
+  ImageDecodeTaskImpl(SoftwareImageDecodeCache* cache,
+                      const SoftwareImageDecodeCache::ImageKey& image_key,
                       const DrawImage& image,
-                      const ImageDecodeController::TracingInfo& tracing_info)
+                      const ImageDecodeCache::TracingInfo& tracing_info)
       : TileTask(true),
-        controller_(controller),
+        cache_(cache),
         image_key_(image_key),
         image_(image),
         tracing_info_(tracing_info) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode",
                  "software", "source_prepare_tiles_id",
                  tracing_info_.prepare_tiles_id);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_.image().get(),
         devtools_instrumentation::ScopedImageDecodeTask::SOFTWARE);
-    controller_->DecodeImage(image_key_, image_);
+    cache_->DecodeImage(image_key_, image_);
   }
 
   // Overridden from TileTask:
-  void OnTaskCompleted() override {
-    controller_->RemovePendingTask(image_key_);
-  }
+  void OnTaskCompleted() override { cache_->RemovePendingTask(image_key_); }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
-  SoftwareImageDecodeController* controller_;
-  SoftwareImageDecodeController::ImageKey image_key_;
+  SoftwareImageDecodeCache* cache_;
+  SoftwareImageDecodeCache::ImageKey image_key_;
   DrawImage image_;
-  const ImageDecodeController::TracingInfo tracing_info_;
+  const ImageDecodeCache::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
-SkSize GetScaleAdjustment(const ImageDecodeControllerKey& key) {
+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()) {
     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);
   }
 }
 
-SkFilterQuality GetDecodedFilterQuality(const ImageDecodeControllerKey& key) {
+SkFilterQuality GetDecodedFilterQuality(const ImageDecodeCacheKey& key) {
   return std::min(key.filter_quality(), kLow_SkFilterQuality);
 }
 
 SkImageInfo CreateImageInfo(size_t width,
                             size_t height,
                             ResourceFormat format) {
   return SkImageInfo::Make(width, height,
                            ResourceFormatToClosestSkColorType(format),
                            kPremul_SkAlphaType);
 }
 
 void RecordLockExistingCachedImageHistogram(TilePriority::PriorityBin bin,
                                             bool success) {
   switch (bin) {
     case TilePriority::NOW:
       UMA_HISTOGRAM_BOOLEAN("Renderer4.LockExistingCachedImage.Software.NOW",
                             success);
     case TilePriority::SOON:
       UMA_HISTOGRAM_BOOLEAN("Renderer4.LockExistingCachedImage.Software.SOON",
                             success);
     case TilePriority::EVENTUALLY:
       UMA_HISTOGRAM_BOOLEAN(
           "Renderer4.LockExistingCachedImage.Software.EVENTUALLY", success);
   }
 }
 
 }  // namespace
 
-SoftwareImageDecodeController::SoftwareImageDecodeController(
+SoftwareImageDecodeCache::SoftwareImageDecodeCache(
     ResourceFormat format,
     size_t locked_memory_limit_bytes)
     : decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
       at_raster_decoded_images_(ImageMRUCache::NO_AUTO_EVICT),
       locked_images_budget_(locked_memory_limit_bytes),
       format_(format),
       max_items_in_cache_(kNormalMaxItemsInCache) {
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-        this, "cc::SoftwareImageDecodeController",
+        this, "cc::SoftwareImageDecodeCache",
         base::ThreadTaskRunnerHandle::Get());
   }
   // Register this component with base::MemoryCoordinatorClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
-SoftwareImageDecodeController::~SoftwareImageDecodeController() {
+SoftwareImageDecodeCache::~SoftwareImageDecodeCache() {
   DCHECK_EQ(0u, decoded_images_ref_counts_.size());
   DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
 
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
   // Unregister this component with memory_coordinator::ClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
-bool SoftwareImageDecodeController::GetTaskForImageAndRef(
+bool SoftwareImageDecodeCache::GetTaskForImageAndRef(
     const DrawImage& image,
     const TracingInfo& tracing_info,
     scoped_refptr<TileTask>* task) {
   // If the image already exists or if we're going to create a task for it, then
   // we'll likely need to ref this image (the exception is if we're prerolling
   // the image only). That means the image is or will be in the cache. When the
   // ref goes to 0, it will be unpinned but will remain in the cache. If the
   // image does not fit into the budget, then we don't ref this image, since it
   // will be decoded at raster time which is when it will be temporarily put in
   // the cache.
   ImageKey key = ImageKey::FromDrawImage(image);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::GetTaskForImageAndRef", "key",
+               "SoftwareImageDecodeCache::GetTaskForImageAndRef", "key",
                key.ToString());
 
   // If the target size is empty, we can skip this image during draw (and thus
   // we don't need to decode it or ref it).
   if (key.target_size().IsEmpty()) {
     *task = nullptr;
     return false;
   }
 
   base::AutoLock lock(lock_);
@@ skipping 51 matching lines @@
   // Actually create the task. RefImage will account for memory on the first
   // ref.
   RefImage(key);
   existing_task = make_scoped_refptr(
       new ImageDecodeTaskImpl(this, key, image, tracing_info));
   *task = existing_task;
   SanityCheckState(__LINE__, true);
   return true;
 }
 
-void SoftwareImageDecodeController::RefImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::RefImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::RefImage", "key",
-               key.ToString());
+               "SoftwareImageDecodeCache::RefImage", "key", key.ToString());
   lock_.AssertAcquired();
   int ref = ++decoded_images_ref_counts_[key];
   if (ref == 1) {
     DCHECK_GE(locked_images_budget_.AvailableMemoryBytes(), key.locked_bytes());
     locked_images_budget_.AddUsage(key.locked_bytes());
   }
 }
 
-void SoftwareImageDecodeController::UnrefImage(const DrawImage& image) {
+void SoftwareImageDecodeCache::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);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::UnrefImage", "key",
-               key.ToString());
+               "SoftwareImageDecodeCache::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) {
     decoded_images_ref_counts_.erase(ref_count_it);
     locked_images_budget_.SubtractUsage(key.locked_bytes());
 
     auto decoded_image_it = decoded_images_.Peek(key);
     // If we've never decoded the image before ref reached 0, then we wouldn't
     // have it in our cache. This would happen if we canceled tasks.
     if (decoded_image_it == decoded_images_.end()) {
       SanityCheckState(__LINE__, true);
       return;
     }
     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",
+void SoftwareImageDecodeCache::DecodeImage(const ImageKey& key,
+                                           const DrawImage& image) {
+  TRACE_EVENT1("cc", "SoftwareImageDecodeCache::DecodeImage", "key",
                key.ToString());
   base::AutoLock lock(lock_);
   AutoRemoveKeyFromTaskMap remove_key_from_task_map(&pending_image_tasks_, key);
 
   // We could have finished all of the raster tasks (cancelled) while the task
   // was just starting to run. Since this task already started running, it
   // wasn't cancelled. So, if the ref count for the image is 0 then we can just
   // abort.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
@@ skipping 36 matching lines @@
   // ref counts. Unlock it immediately in this case.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     decoded_image->Unlock();
   }
 
   decoded_images_.Put(key, std::move(decoded_image));
   SanityCheckState(__LINE__, true);
 }
 
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::DecodeImageInternal(
-    const ImageKey& key,
-    const DrawImage& draw_image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::DecodeImageInternal(const ImageKey& key,
+                                              const DrawImage& draw_image) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::DecodeImageInternal", "key",
+               "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 GetOriginalImageDecode(std::move(image));
     case kMedium_SkFilterQuality:
     case kHigh_SkFilterQuality:
       return GetScaledImageDecode(key, std::move(image));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
-DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDraw(
+DecodedDrawImage SoftwareImageDecodeCache::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
   ImageKey key = ImageKey::FromDrawImage(draw_image);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::GetDecodedImageForDraw", "key",
+               "SoftwareImageDecodeCache::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);
 
   return GetDecodedImageForDrawInternal(key, draw_image);
 }
 
-DecodedDrawImage SoftwareImageDecodeController::GetDecodedImageForDrawInternal(
+DecodedDrawImage SoftwareImageDecodeCache::GetDecodedImageForDrawInternal(
     const ImageKey& key,
     const DrawImage& draw_image) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::GetDecodedImageForDrawInternal",
+               "SoftwareImageDecodeCache::GetDecodedImageForDrawInternal",
                "key", key.ToString());
   base::AutoLock lock(lock_);
   auto decoded_images_it = decoded_images_.Get(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.
   std::unique_ptr<DecodedImage> scoped_decoded_image;
   DecodedImage* decoded_image = nullptr;
   if (decoded_images_it != decoded_images_.end()) {
     decoded_image = decoded_images_it->second.get();
     if (decoded_image->is_locked()) {
@@ skipping 71 matching lines @@
   RefAtRasterImage(key);
   SanityCheckState(__LINE__, true);
   decoded_image->mark_used();
   auto decoded_draw_image =
       DecodedDrawImage(decoded_image->image(), decoded_image->src_rect_offset(),
                        GetScaleAdjustment(key), GetDecodedFilterQuality(key));
   decoded_draw_image.set_at_raster_decode(true);
   return decoded_draw_image;
 }
 
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetOriginalImageDecode(
-    sk_sp<const SkImage> image) {
+std::unique_ptr<SoftwareImageDecodeCache::DecodedImage>
+SoftwareImageDecodeCache::GetOriginalImageDecode(sk_sp<const SkImage> image) {
   SkImageInfo decoded_info =
       CreateImageInfo(image->width(), image->height(), format_);
   std::unique_ptr<base::DiscardableMemory> decoded_pixels;
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "SoftwareImageDecodeController::GetOriginalImageDecode - "
+                 "SoftwareImageDecodeCache::GetOriginalImageDecode - "
                  "allocate decoded pixels");
     decoded_pixels =
         base::DiscardableMemoryAllocator::GetInstance()
             ->AllocateLockedDiscardableMemory(decoded_info.minRowBytes() *
                                               decoded_info.height());
   }
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "SoftwareImageDecodeController::GetOriginalImageDecode - "
+                 "SoftwareImageDecodeCache::GetOriginalImageDecode - "
                  "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;
     }
   }
   return base::MakeUnique<DecodedImage>(decoded_info, std::move(decoded_pixels),
                                         SkSize::Make(0, 0),
                                         next_tracing_id_.GetNext());
 }
 
-std::unique_ptr<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetSubrectImageDecode(
-    const ImageKey& key,
-    sk_sp<const SkImage> image) {
+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());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_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;
 
   SkImageInfo subrect_info = CreateImageInfo(
       key.target_size().width(), key.target_size().height(), format_);
   std::unique_ptr<base::DiscardableMemory> subrect_pixels;
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "SoftwareImageDecodeController::GetSubrectImageDecode - "
+                 "SoftwareImageDecodeCache::GetSubrectImageDecode - "
                  "allocate subrect pixels");
     // TODO(vmpstr): This is using checked math to diagnose a problem reported
     // in crbug.com/662217. If this is causing crashes, then it should be fixed
     // elsewhere by skipping images that are too large.
     base::CheckedNumeric<size_t> byte_size = subrect_info.minRowBytes();
     byte_size *= subrect_info.height();
     subrect_pixels =
         base::DiscardableMemoryAllocator::GetInstance()
             ->AllocateLockedDiscardableMemory(byte_size.ValueOrDie());
   }
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "SoftwareImageDecodeController::GetOriginalImageDecode - "
+                 "SoftwareImageDecodeCache::GetOriginalImageDecode - "
                  "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);
   }
   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<SoftwareImageDecodeController::DecodedImage>
-SoftwareImageDecodeController::GetScaledImageDecode(
-    const ImageKey& key,
-    sk_sp<const SkImage> image) {
+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());
   ImageKey original_size_key =
       ImageKey::FromDrawImage(original_size_draw_image);
   // Sanity checks.
   DCHECK(original_size_key.can_use_original_decode())
@@ skipping 16 matching lines @@
     DCHECK(result) << key.ToString();
   }
 
   DCHECK(!key.target_size().IsEmpty());
   SkImageInfo scaled_info = CreateImageInfo(
       key.target_size().width(), key.target_size().height(), format_);
   std::unique_ptr<base::DiscardableMemory> scaled_pixels;
   {
     TRACE_EVENT0(
         TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-        "SoftwareImageDecodeController::ScaleImage - allocate scaled pixels");
+        "SoftwareImageDecodeCache::ScaleImage - allocate scaled pixels");
     scaled_pixels = base::DiscardableMemoryAllocator::GetInstance()
                         ->AllocateLockedDiscardableMemory(
                             scaled_info.minRowBytes() * scaled_info.height());
   }
   SkPixmap scaled_pixmap(scaled_info, scaled_pixels->data(),
                          scaled_info.minRowBytes());
   DCHECK(key.filter_quality() == kHigh_SkFilterQuality ||
          key.filter_quality() == kMedium_SkFilterQuality);
   {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-                 "SoftwareImageDecodeController::ScaleImage - scale pixels");
+                 "SoftwareImageDecodeCache::ScaleImage - scale pixels");
     bool result =
         decoded_pixmap.scalePixels(scaled_pixmap, key.filter_quality());
     DCHECK(result) << key.ToString();
   }
 
   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 SoftwareImageDecodeController::DrawWithImageFinished(
+void SoftwareImageDecodeCache::DrawWithImageFinished(
     const DrawImage& image,
     const DecodedDrawImage& decoded_image) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::DrawWithImageFinished", "key",
+               "SoftwareImageDecodeCache::DrawWithImageFinished", "key",
                ImageKey::FromDrawImage(image).ToString());
   ImageKey key = ImageKey::FromDrawImage(image);
   if (!decoded_image.image())
     return;
 
   if (decoded_image.is_at_raster_decode())
     UnrefAtRasterImage(key);
   else
     UnrefImage(image);
   SanityCheckState(__LINE__, false);
 }
 
-void SoftwareImageDecodeController::RefAtRasterImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::RefAtRasterImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::RefAtRasterImage", "key",
+               "SoftwareImageDecodeCache::RefAtRasterImage", "key",
                key.ToString());
   DCHECK(at_raster_decoded_images_.Peek(key) !=
          at_raster_decoded_images_.end());
   ++at_raster_decoded_images_ref_counts_[key];
 }
 
-void SoftwareImageDecodeController::UnrefAtRasterImage(const ImageKey& key) {
+void SoftwareImageDecodeCache::UnrefAtRasterImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "SoftwareImageDecodeController::UnrefAtRasterImage", "key",
+               "SoftwareImageDecodeCache::UnrefAtRasterImage", "key",
                key.ToString());
   base::AutoLock lock(lock_);
 
   auto ref_it = at_raster_decoded_images_ref_counts_.find(key);
   DCHECK(ref_it != at_raster_decoded_images_ref_counts_.end());
   --ref_it->second;
   if (ref_it->second == 0) {
     at_raster_decoded_images_ref_counts_.erase(ref_it);
     auto at_raster_image_it = at_raster_decoded_images_.Peek(key);
     DCHECK(at_raster_image_it != at_raster_decoded_images_.end());
@@ skipping 25 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_.Put(key, std::move(at_raster_image_it->second));
     }
     at_raster_decoded_images_.Erase(at_raster_image_it);
   }
 }
 
-void SoftwareImageDecodeController::ReduceCacheUsage() {
-  TRACE_EVENT0("cc", "SoftwareImageDecodeController::ReduceCacheUsage");
+void SoftwareImageDecodeCache::ReduceCacheUsage() {
+  TRACE_EVENT0("cc", "SoftwareImageDecodeCache::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   size_t num_to_remove = (decoded_images_.size() > max_items_in_cache_)
                              ? (decoded_images_.size() - max_items_in_cache_)
                              : 0;
   for (auto it = decoded_images_.rbegin();
        num_to_remove != 0 && it != decoded_images_.rend();) {
     if (it->second->is_locked()) {
       ++it;
       continue;
     }
 
     it = decoded_images_.Erase(it);
     --num_to_remove;
   }
 }
 
-void SoftwareImageDecodeController::RemovePendingTask(const ImageKey& key) {
+void SoftwareImageDecodeCache::RemovePendingTask(const ImageKey& key) {
   base::AutoLock lock(lock_);
   pending_image_tasks_.erase(key);
 }
 
-bool SoftwareImageDecodeController::OnMemoryDump(
+bool SoftwareImageDecodeCache::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
   if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
-    std::string dump_name =
-        base::StringPrintf("cc/image_memory/controller_0x%" PRIXPTR,
-                           reinterpret_cast<uintptr_t>(this));
+    std::string dump_name = base::StringPrintf(
+        "cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
     MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
                     locked_images_budget_.GetCurrentUsageSafe());
   } else {
     // Dump each of our caches.
     DumpImageMemoryForCache(decoded_images_, "cached", pmd);
     DumpImageMemoryForCache(at_raster_decoded_images_, "at_raster", pmd);
   }
 
   // Memory dump can't fail, always return true.
   return true;
 }
 
-void SoftwareImageDecodeController::DumpImageMemoryForCache(
+void SoftwareImageDecodeCache::DumpImageMemoryForCache(
     const ImageMRUCache& cache,
     const char* cache_name,
     base::trace_event::ProcessMemoryDump* pmd) const {
   lock_.AssertAcquired();
 
   for (const auto& image_pair : cache) {
     std::string dump_name = base::StringPrintf(
-        "cc/image_memory/controller_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
+        "cc/image_memory/cache_0x%" PRIXPTR "/%s/image_%" PRIu64 "_id_%d",
         reinterpret_cast<uintptr_t>(this), cache_name,
         image_pair.second->tracing_id(), image_pair.first.image_id());
     // CreateMemoryAllocatorDump will automatically add tracking values for the
     // total size. If locked, we also add a "locked_size" below.
     MemoryAllocatorDump* dump =
         image_pair.second->memory()->CreateMemoryAllocatorDump(
             dump_name.c_str(), pmd);
     DCHECK(dump);
     if (image_pair.second->is_locked()) {
       dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
                       image_pair.first.locked_bytes());
     }
   }
 }
 
-void SoftwareImageDecodeController::SanityCheckState(int line,
-                                                     bool lock_acquired) {
+void SoftwareImageDecodeCache::SanityCheckState(int line, bool lock_acquired) {
 #if DCHECK_IS_ON()
   if (!lock_acquired) {
     base::AutoLock lock(lock_);
     SanityCheckState(line, true);
     return;
   }
 
   MemoryBudget budget(locked_images_budget_.total_limit_bytes());
   for (const auto& image_pair : decoded_images_) {
     const auto& key = image_pair.first;
     const auto& image = image_pair.second;
 
     auto ref_it = decoded_images_ref_counts_.find(key);
     if (image->is_locked()) {
       budget.AddUsage(key.locked_bytes());
       DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
     } else {
       DCHECK(ref_it == decoded_images_ref_counts_.end() ||
              pending_image_tasks_.find(key) != pending_image_tasks_.end())
           << line;
     }
   }
   DCHECK_GE(budget.AvailableMemoryBytes(),
             locked_images_budget_.AvailableMemoryBytes())
       << line;
 #endif  // DCHECK_IS_ON()
 }
 
-// SoftwareImageDecodeControllerKey
-ImageDecodeControllerKey ImageDecodeControllerKey::FromDrawImage(
-    const DrawImage& image) {
+// SoftwareImageDecodeCacheKey
+ImageDecodeCacheKey ImageDecodeCacheKey::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(
@@ skipping 74 matching lines @@
       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 ImageDecodeControllerKey(image.image()->uniqueID(), src_rect,
-                                  target_size, quality, can_use_original_decode,
-                                  should_use_subrect);
+  return ImageDecodeCacheKey(image.image()->uniqueID(), src_rect, target_size,
+                             quality, can_use_original_decode,
+                             should_use_subrect);
 }
 
-ImageDecodeControllerKey::ImageDecodeControllerKey(
-    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,
+                                         SkFilterQuality filter_quality,
+                                         bool can_use_original_decode,
+                                         bool should_use_subrect)
     : image_id_(image_id),
       src_rect_(src_rect),
       target_size_(target_size),
       filter_quality_(filter_quality),
       can_use_original_decode_(can_use_original_decode),
       should_use_subrect_(should_use_subrect) {
   if (can_use_original_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_));
   }
 }
 
-ImageDecodeControllerKey::ImageDecodeControllerKey(
-    const ImageDecodeControllerKey& other) = default;
+ImageDecodeCacheKey::ImageDecodeCacheKey(const ImageDecodeCacheKey& other) =
+    default;
 
-std::string ImageDecodeControllerKey::ToString() const {
+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_
       << "] should_use_subrect [" << should_use_subrect_ << "] hash [" << hash_
       << "]";
   return str.str();
 }
 
 // DecodedImage
-SoftwareImageDecodeController::DecodedImage::DecodedImage(
+SoftwareImageDecodeCache::DecodedImage::DecodedImage(
     const SkImageInfo& info,
     std::unique_ptr<base::DiscardableMemory> memory,
     const SkSize& src_rect_offset,
     uint64_t tracing_id)
     : locked_(true),
       image_info_(info),
       memory_(std::move(memory)),
       src_rect_offset_(src_rect_offset),
       tracing_id_(tracing_id) {
   SkPixmap pixmap(image_info_, memory_->data(), image_info_.minRowBytes());
   image_ = SkImage::MakeFromRaster(
       pixmap, [](const void* pixels, void* context) {}, nullptr);
 }
 
-SoftwareImageDecodeController::DecodedImage::~DecodedImage() {
+SoftwareImageDecodeCache::DecodedImage::~DecodedImage() {
   DCHECK(!locked_);
   // lock_count | used  | last lock failed | result state
   // ===========+=======+==================+==================
   //  1         | false | false            | WASTED
   //  1         | false | true             | WASTED
   //  1         | true  | false            | USED
   //  1         | true  | true             | USED_RELOCK_FAILED
   //  >1        | false | false            | WASTED_RELOCKED
   //  >1        | false | true             | WASTED_RELOCKED
   //  >1        | true  | false            | USED_RELOCKED
@@ skipping 22 matching lines @@
     else
       state = DECODED_IMAGE_STATE_WASTED_RELOCKED;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Renderer4.SoftwareImageDecodeState", state,
                             DECODED_IMAGE_STATE_COUNT);
   UMA_HISTOGRAM_BOOLEAN("Renderer4.SoftwareImageDecodeState.FirstLockWasted",
                         usage_stats_.first_lock_wasted);
 }
 
-bool SoftwareImageDecodeController::DecodedImage::Lock() {
+bool SoftwareImageDecodeCache::DecodedImage::Lock() {
   DCHECK(!locked_);
   bool success = memory_->Lock();
   if (!success) {
     usage_stats_.last_lock_failed = true;
     return false;
   }
   locked_ = true;
   ++usage_stats_.lock_count;
   return true;
 }
 
-void SoftwareImageDecodeController::DecodedImage::Unlock() {
+void SoftwareImageDecodeCache::DecodedImage::Unlock() {
   DCHECK(locked_);
   memory_->Unlock();
   locked_ = false;
   if (usage_stats_.lock_count == 1)
     usage_stats_.first_lock_wasted = !usage_stats_.used;
 }
 
 // MemoryBudget
-SoftwareImageDecodeController::MemoryBudget::MemoryBudget(size_t limit_bytes)
+SoftwareImageDecodeCache::MemoryBudget::MemoryBudget(size_t limit_bytes)
     : limit_bytes_(limit_bytes), current_usage_bytes_(0u) {}
 
-size_t SoftwareImageDecodeController::MemoryBudget::AvailableMemoryBytes()
-    const {
+size_t SoftwareImageDecodeCache::MemoryBudget::AvailableMemoryBytes() const {
   size_t usage = GetCurrentUsageSafe();
   return usage >= limit_bytes_ ? 0u : (limit_bytes_ - usage);
 }
 
-void SoftwareImageDecodeController::MemoryBudget::AddUsage(size_t usage) {
+void SoftwareImageDecodeCache::MemoryBudget::AddUsage(size_t usage) {
   current_usage_bytes_ += usage;
 }
 
-void SoftwareImageDecodeController::MemoryBudget::SubtractUsage(size_t usage) {
+void SoftwareImageDecodeCache::MemoryBudget::SubtractUsage(size_t usage) {
   DCHECK_GE(current_usage_bytes_.ValueOrDefault(0u), usage);
   current_usage_bytes_ -= usage;
 }
 
-void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
+void SoftwareImageDecodeCache::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
-size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
-    const {
+size_t SoftwareImageDecodeCache::MemoryBudget::GetCurrentUsageSafe() const {
   return current_usage_bytes_.ValueOrDie();
 }
 
-void SoftwareImageDecodeController::OnMemoryStateChange(
-    base::MemoryState state) {
+void SoftwareImageDecodeCache::OnMemoryStateChange(base::MemoryState state) {
   {
     base::AutoLock hold(lock_);
     switch (state) {
       case base::MemoryState::NORMAL:
         max_items_in_cache_ = kNormalMaxItemsInCache;
         break;
       case base::MemoryState::THROTTLED:
         max_items_in_cache_ = kThrottledMaxItemsInCache;
         break;
       case base::MemoryState::SUSPENDED:
         max_items_in_cache_ = kSuspendedMaxItemsInCache;
         break;
       case base::MemoryState::UNKNOWN:
         NOTREACHED();
         return;
     }
   }
   ReduceCacheUsage();
 }
 
 }  // namespace cc