cc: Rename ImageDecodeController to ImageDecodeCache.

cc/tiles/software_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_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
-#define CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
+#ifndef CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
+#define CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/atomic_sequence_num.h"
 #include "base/containers/mru_cache.h"
 #include "base/hash.h"
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/memory_coordinator_client.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_math.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "cc/base/cc_export.h"
 #include "cc/playback/decoded_draw_image.h"
 #include "cc/playback/draw_image.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"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
 
-// ImageDecodeControllerKey is a class that gets a cache key out of a given draw
+// ImageDecodeCacheKey is a class that gets a cache key out of a given draw
 // image. That is, this key uniquely identifies an image in the cache. Note that
 // it's insufficient to use SkImage's unique id, since the same image can appear
 // in the cache multiple times at different scales and filter qualities.
-class CC_EXPORT ImageDecodeControllerKey {
+class CC_EXPORT ImageDecodeCacheKey {
  public:
-  static ImageDecodeControllerKey FromDrawImage(const DrawImage& image);
+  static ImageDecodeCacheKey FromDrawImage(const DrawImage& image);
 
-  ImageDecodeControllerKey(const ImageDecodeControllerKey& other);
+  ImageDecodeCacheKey(const ImageDecodeCacheKey& other);
 
-  bool operator==(const ImageDecodeControllerKey& other) const {
+  bool operator==(const ImageDecodeCacheKey& other) const {
     // The image_id always has to be the same. However, after that all original
     // decodes are the same, so if we can use the original decode, return true.
     // If not, then we have to compare every field.
     return image_id_ == other.image_id_ &&
            can_use_original_decode_ == other.can_use_original_decode_ &&
            (can_use_original_decode_ ||
             (src_rect_ == other.src_rect_ &&
              target_size_ == other.target_size_ &&
              filter_quality_ == other.filter_quality_));
   }
 
-  bool operator!=(const ImageDecodeControllerKey& other) const {
+  bool operator!=(const ImageDecodeCacheKey& other) const {
     return !(*this == other);
   }
 
   uint32_t image_id() const { return image_id_; }
   SkFilterQuality filter_quality() const { return filter_quality_; }
   gfx::Rect src_rect() const { return src_rect_; }
   gfx::Size target_size() const { return target_size_; }
 
   bool can_use_original_decode() const { return can_use_original_decode_; }
   bool should_use_subrect() const { return should_use_subrect_; }
   size_t get_hash() const { return hash_; }
 
   // Helper to figure out how much memory the locked image represented by this
   // key would take.
   size_t locked_bytes() const {
     // TODO(vmpstr): Handle formats other than RGBA.
     base::CheckedNumeric<size_t> result = 4;
     result *= target_size_.width();
     result *= target_size_.height();
     return result.ValueOrDefault(std::numeric_limits<size_t>::max());
   }
 
   std::string ToString() const;
 
  private:
-  ImageDecodeControllerKey(uint32_t image_id,
-                           const gfx::Rect& src_rect,
-                           const gfx::Size& size,
-                           SkFilterQuality filter_quality,
-                           bool can_use_original_decode,
-                           bool should_use_subrect);
+  ImageDecodeCacheKey(uint32_t image_id,
+                      const gfx::Rect& src_rect,
+                      const gfx::Size& size,
+                      SkFilterQuality filter_quality,
+                      bool can_use_original_decode,
+                      bool should_use_subrect);
 
   uint32_t image_id_;
   gfx::Rect src_rect_;
   gfx::Size target_size_;
   SkFilterQuality filter_quality_;
   bool can_use_original_decode_;
   bool should_use_subrect_;
   size_t hash_;
 };
 
-// Hash function for the above ImageDecodeControllerKey.
-struct ImageDecodeControllerKeyHash {
-  size_t operator()(const ImageDecodeControllerKey& key) const {
+// Hash function for the above ImageDecodeCacheKey.
+struct ImageDecodeCacheKeyHash {
+  size_t operator()(const ImageDecodeCacheKey& key) const {
     return key.get_hash();
   }
 };
 
-class CC_EXPORT SoftwareImageDecodeController
-    : public ImageDecodeController,
+class CC_EXPORT SoftwareImageDecodeCache
+    : public ImageDecodeCache,
       public base::trace_event::MemoryDumpProvider,
       public base::MemoryCoordinatorClient {
  public:
-  using ImageKey = ImageDecodeControllerKey;
-  using ImageKeyHash = ImageDecodeControllerKeyHash;
+  using ImageKey = ImageDecodeCacheKey;
+  using ImageKeyHash = ImageDecodeCacheKeyHash;
 
-  SoftwareImageDecodeController(ResourceFormat format,
-                                size_t locked_memory_limit_bytes);
-  ~SoftwareImageDecodeController() override;
+  SoftwareImageDecodeCache(ResourceFormat format,
+                           size_t locked_memory_limit_bytes);
+  ~SoftwareImageDecodeCache() override;
 
-  // ImageDecodeController overrides.
+  // ImageDecodeCache overrides.
   bool GetTaskForImageAndRef(const DrawImage& image,
                              const TracingInfo& tracing_info,
                              scoped_refptr<TileTask>* task) override;
   void UnrefImage(const DrawImage& image) override;
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& image) override;
   void DrawWithImageFinished(const DrawImage& image,
                              const DecodedDrawImage& decoded_image) override;
   void ReduceCacheUsage() override;
   // Software doesn't keep outstanding images pinned, so this is a no-op.
   void SetShouldAggressivelyFreeResources(
@@ skipping 27 matching lines @@
 
     const SkSize& src_rect_offset() const { return src_rect_offset_; }
 
     bool is_locked() const { return locked_; }
     bool Lock();
     void Unlock();
 
     const base::DiscardableMemory* memory() const { return memory_.get(); }
 
     // An ID which uniquely identifies this DecodedImage within the image decode
-    // controller. Used in memory tracing.
+    // cache. Used in memory tracing.
     uint64_t tracing_id() const { return tracing_id_; }
     // Mark this image as being used in either a draw or as a source for a
     // scaled image. Either case represents this decode as being valuable and
     // not wasted.
     void mark_used() { usage_stats_.used = true; }
 
    private:
     struct UsageStats {
       // We can only create a decoded image in a locked state, so the initial
       // lock count is 1.
@@ skipping 23 matching lines @@
     void SubtractUsage(size_t usage);
     void ResetUsage();
     size_t total_limit_bytes() const { return limit_bytes_; }
     size_t GetCurrentUsageSafe() const;
 
    private:
     size_t limit_bytes_;
     base::CheckedNumeric<size_t> current_usage_bytes_;
   };
 
-  using ImageMRUCache = base::HashingMRUCache<ImageKey,
-                                              std::unique_ptr<DecodedImage>,
-                                              ImageKeyHash>;
+  using ImageMRUCache = base::
+      HashingMRUCache<ImageKey, std::unique_ptr<DecodedImage>, ImageKeyHash>;
 
   // Looks for the key in the cache and returns true if it was found and was
   // successfully locked (or if it was already locked). Note that if this
   // function returns true, then a ref count is increased for the image.
   bool LockDecodedImageIfPossibleAndRef(const ImageKey& key);
 
   // Actually decode the image. Note that this function can (and should) be
   // called with no lock acquired, since it can do a lot of work. Note that it
   // can also return nullptr to indicate the decode failed.
   std::unique_ptr<DecodedImage> DecodeImageInternal(
@@ skipping 67 matching lines @@
 
   ResourceFormat format_;
   size_t max_items_in_cache_;
 
   // Used to uniquely identify DecodedImages for memory traces.
   base::AtomicSequenceNumber next_tracing_id_;
 };
 
 }  // namespace cc
 
-#endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CONTROLLER_H_
+#endif  // CC_TILES_SOFTWARE_IMAGE_DECODE_CACHE_H_