cc: Rename ImageDecodeController to ImageDecodeCache.

cc/tiles/gpu_image_decode_cache.h

 // 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.
 
-#ifndef CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
-#define CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
+#ifndef CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
+#define CC_TILES_GPU_IMAGE_DECODE_CACHE_H_
 
 #include <memory>
 #include <unordered_map>
 #include <vector>
 
 #include "base/containers/mru_cache.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/memory_coordinator_client.h"
 #include "base/synchronization/lock.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/resources/resource_format.h"
-#include "cc/tiles/image_decode_controller.h"
+#include "cc/tiles/image_decode_cache.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace cc {
 
 class ContextProvider;
 
 // OVERVIEW:
 //
-// GpuImageDecodeController handles the decode and upload of images that will
+// GpuImageDecodeCache handles the decode and upload of images that will
 // be used by Skia's GPU raster path. It also maintains a cache of these
 // decoded/uploaded images for later re-use.
 //
-// Generally, when an image is required for raster, GpuImageDecodeController
+// Generally, when an image is required for raster, GpuImageDecodeCache
 // creates two tasks, one to decode the image, and one to upload the image to
 // the GPU. These tasks are completed before the raster task which depends on
 // the image. We need to seperate decode and upload tasks, as decode can occur
 // simultaneously on multiple threads, while upload requires the GL context
 // lock must happen on our non-concurrent raster thread.
 //
 // Decoded and Uploaded image data share a single cache entry. Depending on how
 // far we've progressed, this cache entry may contain CPU-side decoded data,
 // GPU-side uploaded data, or both. Because CPU-side decoded data is stored in
 // discardable memory, and is only locked for short periods of time (until the
@@ skipping 24 matching lines @@
 //
 // The second cache, |in_use_cache_|, stores one image data per DrawImage -
 // this may be the same ImageData that is in the persistent_cache_.  These
 // cache entries are more transient and are deleted as soon as all refs to the
 // given DrawImage are released (the image is no longer in-use).
 //
 // For examples of raster-scale caching, see https://goo.gl/0zCd9Z
 //
 // REF COUNTING:
 //
-// In dealing with the two caches in GpuImageDecodeController, there are three
+// In dealing with the two caches in GpuImageDecodeCache, there are three
 // ref-counting concepts in use:
 //   1) ImageData upload/decode ref-counts.
 //      These ref-counts represent the overall number of references to the
 //      upload or decode portion of an ImageData. These ref-counts control
 //      both whether the upload/decode data can be freed, as well as whether an
 //      ImageData can be removed from the |persistent_cache_|. ImageDatas are
 //      only removed from the |persistent_cache_| if their upload/decode
 //      ref-counts are zero or if they are orphaned and replaced by a new entry.
 //   2) InUseCacheEntry ref-counts.
 //      These ref-counts represent the number of references to an
 //      InUseCacheEntry from a specific DrawImage. When the InUseCacheEntry's
 //      ref-count reaches 0 it will be deleted.
 //   3) scoped_refptr ref-counts.
 //      Because both the persistent_cache_ and the in_use_cache_ point at the
 //      same ImageDatas (and may need to keep these ImageDatas alive independent
 //      of each other), they hold ImageDatas by scoped_refptr. The scoped_refptr
 //      keeps an ImageData alive while it is present in either the
 //      |persistent_cache_| or |in_use_cache_|.
 //
-class CC_EXPORT GpuImageDecodeController
-    : public ImageDecodeController,
+class CC_EXPORT GpuImageDecodeCache
+    : public ImageDecodeCache,
       public base::trace_event::MemoryDumpProvider,
       public base::MemoryCoordinatorClient {
  public:
-  explicit GpuImageDecodeController(ContextProvider* context,
-                                    ResourceFormat decode_format,
-                                    size_t max_gpu_image_bytes);
-  ~GpuImageDecodeController() override;
+  explicit GpuImageDecodeCache(ContextProvider* context,
+                               ResourceFormat decode_format,
+                               size_t max_gpu_image_bytes);
+  ~GpuImageDecodeCache() override;
 
-  // ImageDecodeController overrides.
+  // ImageDecodeCache overrides.
 
   // Finds the existing uploaded image for the provided DrawImage. Creates an
   // upload task to upload the image if an exsiting image does not exist.
   bool GetTaskForImageAndRef(const DrawImage& image,
                              const TracingInfo& tracing_info,
                              scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& draw_image) override;
   void DrawWithImageFinished(const DrawImage& image,
                              const DecodedDrawImage& decoded_image) override;
@@ skipping 157 matching lines @@
 
   // Ensures that the cache can hold an element of |required_size|, freeing
   // unreferenced cache entries if necessary to make room.
   bool EnsureCapacity(size_t required_size);
   bool CanFitSize(size_t size) const;
   bool ExceedsPreferredCount() const;
 
   void DecodeImageIfNecessary(const DrawImage& draw_image,
                               ImageData* image_data);
 
-  scoped_refptr<GpuImageDecodeController::ImageData> CreateImageData(
+  scoped_refptr<GpuImageDecodeCache::ImageData> CreateImageData(
       const DrawImage& image);
   SkImageInfo CreateImageInfoForDrawImage(const DrawImage& draw_image,
                                           int upload_scale_mip_level) const;
 
   // Finds the ImageData that should be used for the given DrawImage. Looks
   // first in the |in_use_cache_|, and then in the |persistent_cache_|.
   ImageData* GetImageDataForDrawImage(const DrawImage& image);
 
   // Returns true if the given ImageData can be used to draw the specified
   // DrawImage.
@@ skipping 28 matching lines @@
   base::MemoryState memory_state_ = base::MemoryState::NORMAL;
 
   // We can't release GPU backed SkImages without holding the context lock,
   // so we add them to this list and defer deletion until the next time the lock
   // is held.
   std::vector<sk_sp<SkImage>> images_pending_deletion_;
 };
 
 }  // namespace cc
 
-#endif  // CC_TILES_GPU_IMAGE_DECODE_CONTROLLER_H_
+#endif  // CC_TILES_GPU_IMAGE_DECODE_CACHE_H_