cc: Rename ImageDecodeController to ImageDecodeCache.

cc/tiles/gpu_image_decode_cache.cc

 // Copyright 2016 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/gpu_image_decode_controller.h"
+#include "cc/tiles/gpu_image_decode_cache.h"
 
 #include <inttypes.h>
 
 #include "base/debug/alias.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/tile_task.h"
 #include "cc/resources/resource_format_utils.h"
 #include "cc/tiles/mipmap_util.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "gpu_image_decode_controller.h"
+#include "gpu_image_decode_cache.h"
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gl/trace_util.h"
 
 namespace cc {
@@ skipping 91 matching lines @@
   // usage of 32-bit sizes for images, key.mip_level is at most 31.
   int32_t mip_level = CalculateUploadScaleMipLevel(draw_image);
   DCHECK_LT(mip_level, 32);
 
   return (static_cast<uint64_t>(draw_image.image()->uniqueID()) << 32) |
          (mip_level << 16) | filter_quality;
 }
 
 }  // namespace
 
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(
     scoped_refptr<ImageData> image_data)
     : image_data(std::move(image_data)) {}
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(
-    const InUseCacheEntry&) = default;
-GpuImageDecodeController::InUseCacheEntry::InUseCacheEntry(InUseCacheEntry&&) =
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(const InUseCacheEntry&) =
     default;
-GpuImageDecodeController::InUseCacheEntry::~InUseCacheEntry() = default;
+GpuImageDecodeCache::InUseCacheEntry::InUseCacheEntry(InUseCacheEntry&&) =
+    default;
+GpuImageDecodeCache::InUseCacheEntry::~InUseCacheEntry() = default;
 
 // Task which decodes an image and stores the result in discardable memory.
 // This task does not use GPU resources and can be run on any thread.
 class ImageDecodeTaskImpl : public TileTask {
  public:
-  ImageDecodeTaskImpl(GpuImageDecodeController* controller,
+  ImageDecodeTaskImpl(GpuImageDecodeCache* cache,
                       const DrawImage& draw_image,
-                      const ImageDecodeController::TracingInfo& tracing_info)
+                      const ImageDecodeCache::TracingInfo& tracing_info)
       : TileTask(true),
-        controller_(controller),
+        cache_(cache),
         image_(draw_image),
         tracing_info_(tracing_info) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_.image().get(),
         devtools_instrumentation::ScopedImageDecodeTask::GPU);
-    controller_->DecodeImage(image_);
+    cache_->DecodeImage(image_);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
-    controller_->OnImageDecodeTaskCompleted(image_);
+    cache_->OnImageDecodeTaskCompleted(image_);
   }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
-  GpuImageDecodeController* controller_;
+  GpuImageDecodeCache* cache_;
   DrawImage image_;
-  const ImageDecodeController::TracingInfo tracing_info_;
+  const ImageDecodeCache::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 // Task which creates an image from decoded data. Typically this involves
 // uploading data to the GPU, which requires this task be run on the non-
 // concurrent thread.
 class ImageUploadTaskImpl : public TileTask {
  public:
-  ImageUploadTaskImpl(GpuImageDecodeController* controller,
+  ImageUploadTaskImpl(GpuImageDecodeCache* cache,
                       const DrawImage& draw_image,
                       scoped_refptr<TileTask> decode_dependency,
-                      const ImageDecodeController::TracingInfo& tracing_info)
+                      const ImageDecodeCache::TracingInfo& tracing_info)
       : TileTask(false),
-        controller_(controller),
+        cache_(cache),
         image_(draw_image),
         tracing_info_(tracing_info) {
     DCHECK(!SkipImage(draw_image));
     // If an image is already decoded and locked, we will not generate a
     // decode task.
     if (decode_dependency)
       dependencies_.push_back(std::move(decode_dependency));
   }
 
   // Override from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
-    controller_->UploadImage(image_);
+    cache_->UploadImage(image_);
   }
 
   // Overridden from TileTask:
   void OnTaskCompleted() override {
-    controller_->OnImageUploadTaskCompleted(image_);
+    cache_->OnImageUploadTaskCompleted(image_);
   }
 
  protected:
   ~ImageUploadTaskImpl() override {}
 
  private:
-  GpuImageDecodeController* controller_;
+  GpuImageDecodeCache* cache_;
   DrawImage image_;
-  const ImageDecodeController::TracingInfo tracing_info_;
+  const ImageDecodeCache::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
 };
 
-GpuImageDecodeController::DecodedImageData::DecodedImageData() = default;
-GpuImageDecodeController::DecodedImageData::~DecodedImageData() {
+GpuImageDecodeCache::DecodedImageData::DecodedImageData() = default;
+GpuImageDecodeCache::DecodedImageData::~DecodedImageData() {
   ResetData();
 }
 
-bool GpuImageDecodeController::DecodedImageData::Lock() {
+bool GpuImageDecodeCache::DecodedImageData::Lock() {
   DCHECK(!is_locked_);
   is_locked_ = data_->Lock();
   if (is_locked_)
     ++usage_stats_.lock_count;
   return is_locked_;
 }
 
-void GpuImageDecodeController::DecodedImageData::Unlock() {
+void GpuImageDecodeCache::DecodedImageData::Unlock() {
   DCHECK(is_locked_);
   data_->Unlock();
   if (usage_stats_.lock_count == 1)
     usage_stats_.first_lock_wasted = !usage_stats_.used;
   is_locked_ = false;
 }
 
-void GpuImageDecodeController::DecodedImageData::SetLockedData(
+void GpuImageDecodeCache::DecodedImageData::SetLockedData(
     std::unique_ptr<base::DiscardableMemory> data) {
   DCHECK(!is_locked_);
   DCHECK(data);
   DCHECK(!data_);
   data_ = std::move(data);
   is_locked_ = true;
 }
 
-void GpuImageDecodeController::DecodedImageData::ResetData() {
+void GpuImageDecodeCache::DecodedImageData::ResetData() {
   DCHECK(!is_locked_);
   if (data_)
     ReportUsageStats();
   data_ = nullptr;
   usage_stats_ = UsageStats();
 }
 
-void GpuImageDecodeController::DecodedImageData::ReportUsageStats() const {
+void GpuImageDecodeCache::DecodedImageData::ReportUsageStats() const {
   // lock_count │ used  │ result state
   // ═══════════╪═══════╪══════════════════
   //  1         │ false │ WASTED_ONCE
   //  1         │ true  │ USED_ONCE
   //  >1        │ false │ WASTED_RELOCKED
   //  >1        │ true  │ USED_RELOCKED
   // Note that it's important not to reorder the following enums, since the
   // numerical values are used in the histogram code.
   enum State : int {
     DECODED_IMAGE_STATE_WASTED_ONCE,
@@ skipping 14 matching lines @@
     else
       state = DECODED_IMAGE_STATE_WASTED_RELOCKED;
   }
 
   UMA_HISTOGRAM_ENUMERATION("Renderer4.GpuImageDecodeState", state,
                             DECODED_IMAGE_STATE_COUNT);
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageDecodeState.FirstLockWasted",
                         usage_stats_.first_lock_wasted);
 }
 
-GpuImageDecodeController::UploadedImageData::UploadedImageData() = default;
-GpuImageDecodeController::UploadedImageData::~UploadedImageData() {
+GpuImageDecodeCache::UploadedImageData::UploadedImageData() = default;
+GpuImageDecodeCache::UploadedImageData::~UploadedImageData() {
   SetImage(nullptr);
 }
 
-void GpuImageDecodeController::UploadedImageData::SetImage(
-    sk_sp<SkImage> image) {
+void GpuImageDecodeCache::UploadedImageData::SetImage(sk_sp<SkImage> image) {
   DCHECK(!image_ || !image);
   if (image_) {
     ReportUsageStats();
     usage_stats_ = UsageStats();
   }
   image_ = std::move(image);
 }
 
-void GpuImageDecodeController::UploadedImageData::ReportUsageStats() const {
+void GpuImageDecodeCache::UploadedImageData::ReportUsageStats() const {
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.Used",
                         usage_stats_.used);
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuImageUploadState.FirstRefWasted",
                         usage_stats_.first_ref_wasted);
 }
 
-GpuImageDecodeController::ImageData::ImageData(
+GpuImageDecodeCache::ImageData::ImageData(
     DecodedDataMode mode,
     size_t size,
     const SkImage::DeferredTextureImageUsageParams& upload_params)
     : mode(mode), size(size), upload_params(upload_params) {}
 
-GpuImageDecodeController::ImageData::~ImageData() {
+GpuImageDecodeCache::ImageData::~ImageData() {
   // We should never delete ImageData while it is in use or before it has been
   // cleaned up.
   DCHECK_EQ(0u, upload.ref_count);
   DCHECK_EQ(0u, decode.ref_count);
   DCHECK_EQ(false, decode.is_locked());
   // This should always be cleaned up before deleting the image, as it needs to
   // be freed with the GL context lock held.
   DCHECK(!upload.image());
 }
 
-GpuImageDecodeController::GpuImageDecodeController(ContextProvider* context,
-                                                   ResourceFormat decode_format,
-                                                   size_t max_gpu_image_bytes)
+GpuImageDecodeCache::GpuImageDecodeCache(ContextProvider* context,
+                                         ResourceFormat decode_format,
+                                         size_t max_gpu_image_bytes)
     : format_(decode_format),
       context_(context),
       persistent_cache_(PersistentCache::NO_AUTO_EVICT),
       normal_max_gpu_image_bytes_(max_gpu_image_bytes) {
   // Acquire the context_lock so that we can safely retrieve the
   // GrContextThreadSafeProxy. This proxy can then be used with no lock held.
   {
     ContextProvider::ScopedContextLock context_lock(context_);
     context_threadsafe_proxy_ = sk_sp<GrContextThreadSafeProxy>(
         context->GrContext()->threadSafeProxy());
   }
 
   // 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::GpuImageDecodeController",
-        base::ThreadTaskRunnerHandle::Get());
+        this, "cc::GpuImageDecodeCache", base::ThreadTaskRunnerHandle::Get());
   }
   // Register this component with base::MemoryCoordinatorClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
-GpuImageDecodeController::~GpuImageDecodeController() {
+GpuImageDecodeCache::~GpuImageDecodeCache() {
   // SetShouldAggressivelyFreeResources will zero our limits and free all
   // outstanding image memory.
   SetShouldAggressivelyFreeResources(true);
 
   // 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 GpuImageDecodeController::GetTaskForImageAndRef(
-    const DrawImage& draw_image,
-    const TracingInfo& tracing_info,
-    scoped_refptr<TileTask>* task) {
+bool GpuImageDecodeCache::GetTaskForImageAndRef(const DrawImage& draw_image,
+                                                const TracingInfo& tracing_info,
+                                                scoped_refptr<TileTask>* task) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::GetTaskForImageAndRef");
+               "GpuImageDecodeCache::GetTaskForImageAndRef");
   if (SkipImage(draw_image)) {
     *task = nullptr;
     return false;
   }
 
   base::AutoLock lock(lock_);
   const auto image_id = draw_image.image()->uniqueID();
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   scoped_refptr<ImageData> new_data;
   if (!image_data) {
@@ skipping 39 matching lines @@
       this, draw_image, GetImageDecodeTaskAndRef(draw_image, tracing_info),
       tracing_info));
   image_data->upload.task = *task;
 
   // Ref the image again - this ref is owned by the caller, and it is their
   // responsibility to release it by calling UnrefImage.
   RefImage(draw_image);
   return true;
 }
 
-void GpuImageDecodeController::UnrefImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImage(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::UnrefImage");
+               "GpuImageDecodeCache::UnrefImage");
   base::AutoLock lock(lock_);
   UnrefImageInternal(draw_image);
 }
 
-DecodedDrawImage GpuImageDecodeController::GetDecodedImageForDraw(
+DecodedDrawImage GpuImageDecodeCache::GetDecodedImageForDraw(
     const DrawImage& draw_image) {
-  TRACE_EVENT0("cc", "GpuImageDecodeController::GetDecodedImageForDraw");
+  TRACE_EVENT0("cc", "GpuImageDecodeCache::GetDecodedImageForDraw");
 
   // We are being called during raster. The context lock must already be
   // acquired by the caller.
   context_->GetLock()->AssertAcquired();
 
   if (SkipImage(draw_image))
     return DecodedDrawImage(nullptr, draw_image.filter_quality());
 
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
@@ skipping 27 matching lines @@
   DCHECK(image || image_data->decode.decode_failure);
 
   SkSize scale_factor = CalculateScaleFactorForMipLevel(
       draw_image, image_data->upload_params.fPreScaleMipLevel);
   DecodedDrawImage decoded_draw_image(std::move(image), SkSize(), scale_factor,
                                       draw_image.filter_quality());
   decoded_draw_image.set_at_raster_decode(image_data->is_at_raster);
   return decoded_draw_image;
 }
 
-void GpuImageDecodeController::DrawWithImageFinished(
+void GpuImageDecodeCache::DrawWithImageFinished(
     const DrawImage& draw_image,
     const DecodedDrawImage& decoded_draw_image) {
-  TRACE_EVENT0("cc", "GpuImageDecodeController::DrawWithImageFinished");
+  TRACE_EVENT0("cc", "GpuImageDecodeCache::DrawWithImageFinished");
 
   // We are being called during raster. The context lock must already be
   // acquired by the caller.
   context_->GetLock()->AssertAcquired();
 
   if (SkipImage(draw_image))
     return;
 
   base::AutoLock lock(lock_);
   UnrefImageInternal(draw_image);
 
   // We are mid-draw and holding the context lock, ensure we clean up any
   // textures (especially at-raster), which may have just been marked for
   // deletion by UnrefImage.
   DeletePendingImages();
 }
 
-void GpuImageDecodeController::ReduceCacheUsage() {
+void GpuImageDecodeCache::ReduceCacheUsage() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::ReduceCacheUsage");
+               "GpuImageDecodeCache::ReduceCacheUsage");
   base::AutoLock lock(lock_);
   EnsureCapacity(0);
 }
 
-void GpuImageDecodeController::SetShouldAggressivelyFreeResources(
+void GpuImageDecodeCache::SetShouldAggressivelyFreeResources(
     bool aggressively_free_resources) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::SetShouldAggressivelyFreeResources",
+               "GpuImageDecodeCache::SetShouldAggressivelyFreeResources",
                "agressive_free_resources", aggressively_free_resources);
   if (aggressively_free_resources) {
     ContextProvider::ScopedContextLock context_lock(context_);
     base::AutoLock lock(lock_);
     // We want to keep as little in our cache as possible. Set our memory limit
     // to zero and EnsureCapacity to clean up memory.
     cached_bytes_limit_ = kSuspendedOrInvisibleMaxGpuImageBytes;
     EnsureCapacity(0);
 
     // We are holding the context lock, so finish cleaning up deleted images
     // now.
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
     cached_bytes_limit_ = normal_max_gpu_image_bytes_;
   }
 }
 
-bool GpuImageDecodeController::OnMemoryDump(
+bool GpuImageDecodeCache::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   using base::trace_event::MemoryAllocatorDump;
   using base::trace_event::MemoryAllocatorDumpGuid;
   using base::trace_event::MemoryDumpLevelOfDetail;
 
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::OnMemoryDump");
+               "GpuImageDecodeCache::OnMemoryDump");
 
   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(MemoryAllocatorDump::kNameSize,
                     MemoryAllocatorDump::kUnitsBytes, bytes_used_);
 
     // Early out, no need for more detail in a BACKGROUND dump.
     return true;
   }
 
   for (const auto& image_pair : persistent_cache_) {
     const ImageData* image_data = image_pair.second.get();
     const uint32_t image_id = image_pair.first;
 
     // If we have discardable decoded data, dump this here.
     if (image_data->decode.data()) {
       std::string discardable_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
+          "cc/image_memory/cache_0x%" PRIXPTR "/discardable/image_%d",
           reinterpret_cast<uintptr_t>(this), image_id);
       MemoryAllocatorDump* dump =
           image_data->decode.data()->CreateMemoryAllocatorDump(
               discardable_dump_name.c_str(), pmd);
       // If our image is locked, dump the "locked_size" as an additional
       // column.
       // This lets us see the amount of discardable which is contributing to
       // memory pressure.
       if (image_data->decode.is_locked()) {
         dump->AddScalar("locked_size", MemoryAllocatorDump::kUnitsBytes,
                         image_data->size);
       }
     }
 
     // If we have an uploaded image (that is actually on the GPU, not just a
     // CPU
     // wrapper), upload it here.
     if (image_data->upload.image() &&
         image_data->mode == DecodedDataMode::GPU) {
       std::string gpu_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_0x%" PRIXPTR "/gpu/image_%d",
+          "cc/image_memory/cache_0x%" PRIXPTR "/gpu/image_%d",
           reinterpret_cast<uintptr_t>(this), image_id);
       MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(gpu_dump_name);
       dump->AddScalar(MemoryAllocatorDump::kNameSize,
                       MemoryAllocatorDump::kUnitsBytes, image_data->size);
 
       // Create a global shred GUID to associate this data with its GPU
       // process
       // counterpart.
       GLuint gl_id = skia::GrBackendObjectToGrGLTextureInfo(
                          image_data->upload.image()->getTextureHandle(
                              false /* flushPendingGrContextIO */))
                          ->fID;
       MemoryAllocatorDumpGuid guid = gl::GetGLTextureClientGUIDForTracing(
           context_->ContextSupport()->ShareGroupTracingGUID(), gl_id);
 
       // kImportance is somewhat arbitrary - we chose 3 to be higher than the
       // value used in the GPU process (1), and Skia (2), causing us to appear
       // as the owner in memory traces.
       const int kImportance = 3;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
-void GpuImageDecodeController::DecodeImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::DecodeImage(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::DecodeImage");
+               "GpuImageDecodeCache::DecodeImage");
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
   DecodeImageIfNecessary(draw_image, image_data);
 }
 
-void GpuImageDecodeController::UploadImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UploadImage(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::UploadImage");
+               "GpuImageDecodeCache::UploadImage");
   ContextProvider::ScopedContextLock context_lock(context_);
   base::AutoLock lock(lock_);
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(!image_data->is_at_raster);
   UploadImageIfNecessary(draw_image, image_data);
 }
 
-void GpuImageDecodeController::OnImageDecodeTaskCompleted(
+void GpuImageDecodeCache::OnImageDecodeTaskCompleted(
     const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::OnImageDecodeTaskCompleted");
+               "GpuImageDecodeCache::OnImageDecodeTaskCompleted");
   base::AutoLock lock(lock_);
   // Decode task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(image_data->decode.task);
   image_data->decode.task = nullptr;
 
   // While the decode task is active, we keep a ref on the decoded data.
   // Release that ref now.
   UnrefImageDecode(draw_image);
 }
 
-void GpuImageDecodeController::OnImageUploadTaskCompleted(
+void GpuImageDecodeCache::OnImageUploadTaskCompleted(
     const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::OnImageUploadTaskCompleted");
+               "GpuImageDecodeCache::OnImageUploadTaskCompleted");
   base::AutoLock lock(lock_);
   // Upload task is complete, remove our reference to it.
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   DCHECK(image_data->upload.task);
   image_data->upload.task = nullptr;
 
   // While the upload task is active, we keep a ref on both the image it will be
   // populating, as well as the decode it needs to populate it. Release these
   // refs now.
   UnrefImageDecode(draw_image);
   UnrefImageInternal(draw_image);
 }
 
 // Checks if an existing image decode exists. If not, returns a task to produce
 // the requested decode.
-scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
+scoped_refptr<TileTask> GpuImageDecodeCache::GetImageDecodeTaskAndRef(
     const DrawImage& draw_image,
     const TracingInfo& tracing_info) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::GetImageDecodeTaskAndRef");
+               "GpuImageDecodeCache::GetImageDecodeTaskAndRef");
   lock_.AssertAcquired();
 
   // This ref is kept alive while an upload task may need this decode. We
   // release this ref in UploadTaskCompleted.
   RefImageDecode(draw_image);
 
   ImageData* image_data = GetImageDataForDrawImage(draw_image);
   DCHECK(image_data);
   if (image_data->decode.is_locked()) {
     // We should never be creating a decode task for an at raster image.
     DCHECK(!image_data->is_at_raster);
     // We should never be creating a decode for an already-uploaded image.
     DCHECK(!image_data->upload.image());
     return nullptr;
   }
 
   // We didn't have an existing locked image, create a task to lock or decode.
   scoped_refptr<TileTask>& existing_task = image_data->decode.task;
   if (!existing_task) {
     // Ref image decode and create a decode task. This ref will be released in
     // DecodeTaskCompleted.
     RefImageDecode(draw_image);
     existing_task = make_scoped_refptr(
         new ImageDecodeTaskImpl(this, draw_image, tracing_info));
   }
   return existing_task;
 }
 
-void GpuImageDecodeController::RefImageDecode(const DrawImage& draw_image) {
+void GpuImageDecodeCache::RefImageDecode(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::RefImageDecode");
+               "GpuImageDecodeCache::RefImageDecode");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   ++found->second.ref_count;
   ++found->second.image_data->decode.ref_count;
   OwnershipChanged(draw_image, found->second.image_data.get());
 }
 
-void GpuImageDecodeController::UnrefImageDecode(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImageDecode(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::UnrefImageDecode");
+               "GpuImageDecodeCache::UnrefImageDecode");
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   DCHECK_GT(found->second.image_data->decode.ref_count, 0u);
   DCHECK_GT(found->second.ref_count, 0u);
   --found->second.ref_count;
   --found->second.image_data->decode.ref_count;
   OwnershipChanged(draw_image, found->second.image_data.get());
   if (found->second.ref_count == 0u) {
     in_use_cache_.erase(found);
   }
 }
 
-void GpuImageDecodeController::RefImage(const DrawImage& draw_image) {
+void GpuImageDecodeCache::RefImage(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::RefImage");
+               "GpuImageDecodeCache::RefImage");
   lock_.AssertAcquired();
   InUseCacheKey key = GenerateInUseCacheKey(draw_image);
   auto found = in_use_cache_.find(key);
 
   // If no secondary cache entry was found for the given |draw_image|, then
   // the draw_image only exists in the |persistent_cache_|. Create an in-use
   // cache entry now.
   if (found == in_use_cache_.end()) {
     auto found_image = persistent_cache_.Peek(draw_image.image()->uniqueID());
     DCHECK(found_image != persistent_cache_.end());
     DCHECK(found_image->second->upload_params.fPreScaleMipLevel <=
            CalculateUploadScaleMipLevel(draw_image));
     found = in_use_cache_
                 .insert(InUseCache::value_type(
                     key, InUseCacheEntry(found_image->second)))
                 .first;
   }
 
   DCHECK(found != in_use_cache_.end());
   ++found->second.ref_count;
   ++found->second.image_data->upload.ref_count;
   OwnershipChanged(draw_image, found->second.image_data.get());
 }
 
-void GpuImageDecodeController::UnrefImageInternal(const DrawImage& draw_image) {
+void GpuImageDecodeCache::UnrefImageInternal(const DrawImage& draw_image) {
   lock_.AssertAcquired();
   auto found = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   DCHECK(found != in_use_cache_.end());
   DCHECK_GT(found->second.image_data->upload.ref_count, 0u);
   DCHECK_GT(found->second.ref_count, 0u);
   --found->second.ref_count;
   --found->second.image_data->upload.ref_count;
   OwnershipChanged(draw_image, found->second.image_data.get());
   if (found->second.ref_count == 0u) {
     in_use_cache_.erase(found);
   }
 }
 
 // Called any time an image or decode ref count changes. Takes care of any
 // necessary memory budget book-keeping and cleanup.
-void GpuImageDecodeController::OwnershipChanged(const DrawImage& draw_image,
-                                                ImageData* image_data) {
+void GpuImageDecodeCache::OwnershipChanged(const DrawImage& draw_image,
+                                           ImageData* image_data) {
   lock_.AssertAcquired();
 
   bool has_any_refs =
       image_data->upload.ref_count > 0 || image_data->decode.ref_count > 0;
 
   // Don't keep around completely empty images. This can happen if an image's
   // decode/upload tasks were both cancelled before completing.
   if (!has_any_refs && !image_data->upload.image() &&
       !image_data->decode.data()) {
     auto found_persistent =
@@ skipping 75 matching lines @@
       DCHECK(image_data->decode.is_locked());
   } else {
     DCHECK(!image_data->upload.budgeted || image_data->upload.ref_count > 0);
   }
 #endif
 }
 
 // Ensures that we can fit a new image of size |required_size| in our cache. In
 // doing so, this function will free unreferenced image data as necessary to
 // create rooom.
-bool GpuImageDecodeController::EnsureCapacity(size_t required_size) {
+bool GpuImageDecodeCache::EnsureCapacity(size_t required_size) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::EnsureCapacity");
+               "GpuImageDecodeCache::EnsureCapacity");
   lock_.AssertAcquired();
 
   if (CanFitSize(required_size) && !ExceedsPreferredCount())
     return true;
 
   // While we are over memory or preferred item capacity, we iterate through
   // our set of cached image data in LRU order. For each image, we can do two
   // things: 1) We can free the uploaded image, reducing the memory usage of
   // the cache and 2) we can remove the entry entirely, reducing the count of
   // elements in the cache.
@@ skipping 30 matching lines @@
 
     if (CanFitSize(required_size) && !ExceedsPreferredCount())
       return true;
   }
 
   // Preferred count is only used as a guideline when triming the cache. Allow
   // new elements to be added as long as we are below our size limit.
   return CanFitSize(required_size);
 }
 
-bool GpuImageDecodeController::CanFitSize(size_t size) const {
+bool GpuImageDecodeCache::CanFitSize(size_t size) const {
   lock_.AssertAcquired();
 
   size_t bytes_limit;
   if (memory_state_ == base::MemoryState::NORMAL) {
     bytes_limit = cached_bytes_limit_;
   } else if (memory_state_ == base::MemoryState::THROTTLED) {
     bytes_limit = cached_bytes_limit_ / kThrottledCacheSizeReductionFactor;
   } else {
     DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
     bytes_limit = kSuspendedOrInvisibleMaxGpuImageBytes;
   }
 
   base::CheckedNumeric<uint32_t> new_size(bytes_used_);
   new_size += size;
   return new_size.IsValid() && new_size.ValueOrDie() <= bytes_limit;
 }
 
-bool GpuImageDecodeController::ExceedsPreferredCount() const {
+bool GpuImageDecodeCache::ExceedsPreferredCount() const {
   lock_.AssertAcquired();
 
   size_t items_limit;
   if (memory_state_ == base::MemoryState::NORMAL) {
     items_limit = kNormalMaxItemsInCache;
   } else if (memory_state_ == base::MemoryState::THROTTLED) {
     items_limit = kThrottledMaxItemsInCache;
   } else {
     DCHECK_EQ(base::MemoryState::SUSPENDED, memory_state_);
     items_limit = kSuspendedMaxItemsInCache;
   }
 
   return persistent_cache_.size() > items_limit;
 }
 
-void GpuImageDecodeController::DecodeImageIfNecessary(
-    const DrawImage& draw_image,
-    ImageData* image_data) {
+void GpuImageDecodeCache::DecodeImageIfNecessary(const DrawImage& draw_image,
+                                                 ImageData* image_data) {
   lock_.AssertAcquired();
 
   DCHECK_GT(image_data->decode.ref_count, 0u);
 
   if (image_data->decode.decode_failure) {
     // We have already tried and failed to decode this image. Don't try again.
     return;
   }
 
   if (image_data->upload.image()) {
     // We already have an uploaded image, no reason to decode.
     return;
   }
 
   if (image_data->decode.data() &&
       (image_data->decode.is_locked() || image_data->decode.Lock())) {
     // We already decoded this, or we just needed to lock, early out.
     return;
   }
 
-  TRACE_EVENT0("cc", "GpuImageDecodeController::DecodeImage");
+  TRACE_EVENT0("cc", "GpuImageDecodeCache::DecodeImage");
 
   image_data->decode.ResetData();
   std::unique_ptr<base::DiscardableMemory> backing_memory;
   {
     base::AutoUnlock unlock(lock_);
 
     backing_memory = base::DiscardableMemoryAllocator::GetInstance()
                          ->AllocateLockedDiscardableMemory(image_data->size);
 
     switch (image_data->mode) {
@@ skipping 38 matching lines @@
 
   if (!backing_memory) {
     // If |backing_memory| was not populated, we had a non-decodable image.
     image_data->decode.decode_failure = true;
     return;
   }
 
   image_data->decode.SetLockedData(std::move(backing_memory));
 }
 
-void GpuImageDecodeController::UploadImageIfNecessary(
-    const DrawImage& draw_image,
-    ImageData* image_data) {
+void GpuImageDecodeCache::UploadImageIfNecessary(const DrawImage& draw_image,
+                                                 ImageData* image_data) {
   context_->GetLock()->AssertAcquired();
   lock_.AssertAcquired();
 
   if (image_data->decode.decode_failure) {
     // We were unnable to decode this image. Don't try to upload.
     return;
   }
 
   if (image_data->upload.image()) {
     // Someone has uploaded this image before us (at raster).
     return;
   }
 
-  TRACE_EVENT0("cc", "GpuImageDecodeController::UploadImage");
+  TRACE_EVENT0("cc", "GpuImageDecodeCache::UploadImage");
   DCHECK(image_data->decode.is_locked());
   DCHECK_GT(image_data->decode.ref_count, 0u);
   DCHECK_GT(image_data->upload.ref_count, 0u);
 
   // We are about to upload a new image and are holding the context lock.
   // Ensure that any images which have been marked for deletion are actually
   // cleaned up so we don't exceed our memory limit during this upload.
   DeletePendingImages();
 
   sk_sp<SkImage> uploaded_image;
@@ skipping 19 matching lines @@
   }
   image_data->decode.mark_used();
   DCHECK(uploaded_image);
 
   // At-raster may have decoded this while we were unlocked. If so, ignore our
   // result.
   if (!image_data->upload.image())
     image_data->upload.SetImage(std::move(uploaded_image));
 }
 
-scoped_refptr<GpuImageDecodeController::ImageData>
-GpuImageDecodeController::CreateImageData(const DrawImage& draw_image) {
+scoped_refptr<GpuImageDecodeCache::ImageData>
+GpuImageDecodeCache::CreateImageData(const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::CreateImageData");
+               "GpuImageDecodeCache::CreateImageData");
   lock_.AssertAcquired();
 
   DecodedDataMode mode;
   int upload_scale_mip_level = CalculateUploadScaleMipLevel(draw_image);
   auto params = SkImage::DeferredTextureImageUsageParams(
       draw_image.matrix(), CalculateUploadScaleFilterQuality(draw_image),
       upload_scale_mip_level);
   size_t data_size = draw_image.image()->getDeferredTextureImageData(
       *context_threadsafe_proxy_.get(), &params, 1, nullptr);
 
   if (data_size == 0) {
     // Can't upload image, too large or other failure. Try to use SW fallback.
     SkImageInfo image_info =
         CreateImageInfoForDrawImage(draw_image, upload_scale_mip_level);
     data_size = image_info.getSafeSize(image_info.minRowBytes());
     mode = DecodedDataMode::CPU;
   } else {
     mode = DecodedDataMode::GPU;
   }
 
   return make_scoped_refptr(new ImageData(mode, data_size, params));
 }
 
-void GpuImageDecodeController::DeletePendingImages() {
+void GpuImageDecodeCache::DeletePendingImages() {
   context_->GetLock()->AssertAcquired();
   lock_.AssertAcquired();
   images_pending_deletion_.clear();
 }
 
-SkImageInfo GpuImageDecodeController::CreateImageInfoForDrawImage(
+SkImageInfo GpuImageDecodeCache::CreateImageInfoForDrawImage(
     const DrawImage& draw_image,
     int upload_scale_mip_level) const {
   gfx::Size mip_size =
       CalculateSizeForMipLevel(draw_image, upload_scale_mip_level);
   return SkImageInfo::Make(mip_size.width(), mip_size.height(),
                            ResourceFormatToClosestSkColorType(format_),
                            kPremul_SkAlphaType);
 }
 
 // Tries to find an ImageData that can be used to draw the provided
 // |draw_image|. First looks for an exact entry in our |in_use_cache_|. If one
 // cannot be found, it looks for a compatible entry in our |persistent_cache_|.
-GpuImageDecodeController::ImageData*
-GpuImageDecodeController::GetImageDataForDrawImage(
+GpuImageDecodeCache::ImageData* GpuImageDecodeCache::GetImageDataForDrawImage(
     const DrawImage& draw_image) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
-               "GpuImageDecodeController::GetImageDataForDrawImage");
+               "GpuImageDecodeCache::GetImageDataForDrawImage");
   lock_.AssertAcquired();
   auto found_in_use = in_use_cache_.find(GenerateInUseCacheKey(draw_image));
   if (found_in_use != in_use_cache_.end())
     return found_in_use->second.image_data.get();
 
   auto found_persistent = persistent_cache_.Get(draw_image.image()->uniqueID());
   if (found_persistent != persistent_cache_.end()) {
     ImageData* image_data = found_persistent->second.get();
     if (IsCompatible(image_data, draw_image)) {
       return image_data;
     } else {
       found_persistent->second->is_orphaned = true;
       // Call OwnershipChanged before erasing the orphaned task from the
       // persistent cache. This ensures that if the orphaned task has 0
       // references, it is cleaned up safely before it is deleted.
       OwnershipChanged(draw_image, image_data);
       persistent_cache_.Erase(found_persistent);
     }
   }
 
   return nullptr;
 }
 
 // Determines if we can draw the provided |draw_image| using the provided
 // |image_data|. This is true if the |image_data| is not scaled, or if it
 // is scaled at an equal or larger scale and equal or larger quality to
 // the provided |draw_image|.
-bool GpuImageDecodeController::IsCompatible(const ImageData* image_data,
-                                            const DrawImage& draw_image) const {
+bool GpuImageDecodeCache::IsCompatible(const ImageData* image_data,
+                                       const DrawImage& draw_image) const {
   bool is_scaled = image_data->upload_params.fPreScaleMipLevel != 0;
   bool scale_is_compatible = CalculateUploadScaleMipLevel(draw_image) >=
                              image_data->upload_params.fPreScaleMipLevel;
   bool quality_is_compatible = CalculateUploadScaleFilterQuality(draw_image) <=
                                image_data->upload_params.fQuality;
   return !is_scaled || (scale_is_compatible && quality_is_compatible);
 }
 
-size_t GpuImageDecodeController::GetDrawImageSizeForTesting(
-    const DrawImage& image) {
+size_t GpuImageDecodeCache::GetDrawImageSizeForTesting(const DrawImage& image) {
   base::AutoLock lock(lock_);
   scoped_refptr<ImageData> data = CreateImageData(image);
   return data->size;
 }
 
-void GpuImageDecodeController::SetImageDecodingFailedForTesting(
+void GpuImageDecodeCache::SetImageDecodingFailedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = persistent_cache_.Peek(image.image()->uniqueID());
   DCHECK(found != persistent_cache_.end());
   ImageData* image_data = found->second.get();
   image_data->decode.decode_failure = true;
 }
 
-bool GpuImageDecodeController::DiscardableIsLockedForTesting(
+bool GpuImageDecodeCache::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = persistent_cache_.Peek(image.image()->uniqueID());
   DCHECK(found != persistent_cache_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked();
 }
 
-void GpuImageDecodeController::OnMemoryStateChange(base::MemoryState state) {
+void GpuImageDecodeCache::OnMemoryStateChange(base::MemoryState state) {
   switch (state) {
     case base::MemoryState::NORMAL:
       memory_state_ = state;
       break;
     case base::MemoryState::THROTTLED:
     case base::MemoryState::SUSPENDED: {
       memory_state_ = state;
 
       // We've just changed our memory state to a (potentially) more
       // restrictive one. Re-enforce cache limits.
       base::AutoLock lock(lock_);
       EnsureCapacity(0);
       break;
     }
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc