cc: Add image decode control in the compositor.

cc/tiles/image_decode_controller.h

 // 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.
 
 #ifndef CC_TILES_IMAGE_DECODE_CONTROLLER_H_
 #define CC_TILES_IMAGE_DECODE_CONTROLLER_H_
 
 #include "base/containers/hash_tables.h"
+#include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ref_counted.h"
+#include "base/numerics/safe_math.h"
 #include "cc/base/cc_export.h"
 #include "cc/playback/discardable_image_map.h"
 #include "cc/raster/tile_task_runner.h"
 #include "skia/ext/refptr.h"
 
+#include "ui/gfx/transform.h"
+
 namespace cc {
 
+class ImageDecodeControllerKey {
+ public:
+  static ImageDecodeControllerKey FromDrawImage(const DrawImage& image);
+
+  ImageDecodeControllerKey(uint32_t image_id,
+                           const gfx::Size& size,
+                           SkFilterQuality filter_quality);
+
+  bool operator==(const ImageDecodeControllerKey& other) const {
+    return image_id_ == other.image_id_ && size_ == other.size_ &&
+           filter_quality_ == other.filter_quality_;
+  }
+
+  uint32_t image_id() const { return image_id_; }
+  gfx::Size target_size() const { return size_; }
+  size_t target_bytes() const {
+    base::CheckedNumeric<size_t> result = 4;
+    result *= size_.width();
+    result *= size_.height();
+    return result.ValueOrDefault(std::numeric_limits<size_t>::max());
+  }
+  SkFilterQuality filter_quality() const { return filter_quality_; }
+
+  std::string ToString() const;
+
+ private:
+  uint32_t image_id_;
+  gfx::Size size_;
+  SkFilterQuality filter_quality_;
+};
+
+}  // namespace cc
+
+namespace BASE_HASH_NAMESPACE {
+template <>
+struct hash<cc::ImageDecodeControllerKey> {
+  size_t operator()(const cc::ImageDecodeControllerKey& key) const {
+    return base::HashPair(
+        base::HashPair(key.target_size().width(), key.target_size().height()),
+        base::HashPair(key.image_id(), key.filter_quality()));
+  }
+};
+}  // namespace BASE_HASH_NAMESPACE
+
+namespace cc {
 class ImageDecodeController {
  public:
+  using ImageKey = ImageDecodeControllerKey;
+
   ImageDecodeController();
   ~ImageDecodeController();
 
-  scoped_refptr<ImageDecodeTask> GetTaskForImage(const DrawImage& image,
-                                                 int layer_id,
-                                                 uint64_t prepare_tiles_id);
+  // Returns an ImageDecodeTask which will decode the given image when run. In
+  // case the image is already cached, returns nullptr.
+  // Note that every time this function is called, a ref count is accumulated.
+  // This count is decremented when UnlockImageForTile is called. When the
+  // count reaches 0, the image is unpinned.
+  scoped_refptr<ImageDecodeTask> GetTaskForImageAndRef(
+      const DrawImage& image,
+      uint64_t prepare_tiles_id);
+  DecodedDrawImage GetDecodedImageAndRef(const DrawImage& image);
+
+  void DrawWithImageFinished(const DrawImage& image);

[enne (OOO), 2015/10/29 22:59:45]

What's the Finished part here mean? Could this function and
GetDecodedImageAndRef get some block comments too?

+  void UnrefImage(const DrawImage& image);
 
   // Note that this function has to remain thread safe.

[enne (OOO), 2015/10/29 22:59:45]

Should other functions check that they're called on the right thread?

-  void DecodeImage(const SkImage* image);
+  void DecodeImage(const ImageKey& key, const DrawImage& image);
 
-  // TODO(vmpstr): This should go away once the controller is decoding images
-  // based on priority and memory.
-  void AddLayerUsedCount(int layer_id);
-  void SubtractLayerUsedCount(int layer_id);
-
-  void OnImageDecodeTaskCompleted(int layer_id,
-                                  const SkImage* image,
-                                  bool was_canceled);
+  void OnImageDecodeTaskCompleted(const ImageKey& key, bool was_canceled);
+  void ReduceCacheUsage();
 
  private:
-  scoped_refptr<ImageDecodeTask> CreateTaskForImage(const SkImage* image,
-                                                    int layer_id,
+  class DecodedImage : public base::RefCounted<DecodedImage> {
+   public:
+    DecodedImage(const SkImageInfo& info,
+                 scoped_ptr<base::DiscardableMemory> memory);
+
+    SkImage* image() const {
+      DCHECK(locked_);
+      return image_.get();
+    }
+
+    bool is_locked() const { return locked_; }
+    bool Lock();
+    void Unlock();
+
+   private:
+    friend class base::RefCounted<DecodedImage>;
+
+    ~DecodedImage();
+    void CreateImageFromLockedMemory();
+
+    bool locked_;
+    SkImageInfo image_info_;
+    scoped_ptr<base::DiscardableMemory> memory_;
+    skia::RefPtr<SkImage> image_;
+  };
+
+  class MemoryBudget {
+   public:
+    explicit MemoryBudget(size_t limit_bytes);
+
+    size_t AvailableMemoryBytes() const;
+    void AddUsage(size_t usage);
+    void SubtractUsage(size_t usage);
+    void ResetUsage();
+    bool NeedsReset() const;
+
+   private:
+    size_t GetCurrentUsageSafe() const;
+
+    size_t limit_bytes_;
+    base::CheckedNumeric<size_t> current_usage_bytes_;
+  };
+
+  scoped_refptr<ImageDecodeTask> CreateTaskForImage(const ImageKey& key,
+                                                    const DrawImage& image,
                                                     uint64_t prepare_tiles_id);
+  bool LockDecodedImageIfPossibleAndRef(const ImageKey& key);
+  scoped_refptr<DecodedImage> DecodeImageInternal(const ImageKey& key,
+                                                  const SkImage* image);
+  bool CanHandleFilterQuality(SkFilterQuality filter_quality);
+  void SanityCheckState(int line, bool lock_acquired);
 
-  using ImageTaskMap = base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>;
-  using LayerImageTaskMap = base::hash_map<int, ImageTaskMap>;
-  LayerImageTaskMap image_decode_tasks_;
+  base::hash_map<ImageKey, scoped_refptr<ImageDecodeTask>> pending_image_tasks_;
+  using AnnotatedDecodedImage =
+      std::pair<ImageKey, scoped_refptr<DecodedImage>>;
 
-  using LayerCountMap = base::hash_map<int, int>;
-  LayerCountMap used_layer_counts_;
+  // The rest of the members can only be accessed if the lock is held to ensure
+  // that they are safe to access on multiple threads.
+  base::Lock lock_;
+  std::deque<AnnotatedDecodedImage> decoded_images_;
+  base::hash_map<ImageKey, int> decoded_images_ref_counts_;
+  MemoryBudget locked_images_budget_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_IMAGE_DECODE_CONTROLLER_H_