(not for review) nwayover

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 "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 ImageDecodeController {
  public:
+  class ImageKey {
+   public:
+    static ImageKey FromImageData(const SkImage* image,
+                                  const SkMatrix& matrix,
+                                  SkFilterQuality filter_quality);
+
+    ImageKey(uint32_t image_id,
+             const gfx::Size& size,
+             SkFilterQuality filter_quality);
+
+    bool operator==(const ImageKey& other) const {
+      return image_id_ == other.image_id_ && size_ == other.size_ &&
+             filter_quality_ == other.filter_quality_;
+    }
+
+    gfx::Size target_size() const { return size_; }
+
+   private:
+    uint32_t image_id_;
+    gfx::Size size_;
+    SkFilterQuality filter_quality_;
+  };
+
   ImageDecodeController();
   ~ImageDecodeController();
 
   scoped_refptr<ImageDecodeTask> GetTaskForImage(const PositionImage& image,
-                                                 int layer_id,
                                                  uint64_t prepare_tiles_id);
 
   // Note that this function has to remain thread safe.
-  void DecodeImage(const SkImage* image);
+  void DecodeImage(const ImageKey& key, const PositionImage& 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(const ImageKey& key, bool was_canceled);
 
-  void OnImageDecodeTaskCompleted(int layer_id,
-                                  const SkImage* image,
-                                  bool was_canceled);
+  DecodedPositionImage GetDecodedImage(const PositionImage& image);
 
  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_;
+  };
+
+  scoped_refptr<ImageDecodeTask> CreateTaskForImage(const ImageKey& key,
+                                                    const PositionImage& image,
                                                     uint64_t prepare_tiles_id);
+  bool LockDecodedImageIfPossible(const ImageKey& key);
 
-  using ImageTaskMap = base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>;
-  using LayerImageTaskMap = base::hash_map<int, ImageTaskMap>;
-  LayerImageTaskMap image_decode_tasks_;
+  using AnnotatedDecodeTask =
+      std::pair<ImageKey, scoped_refptr<ImageDecodeTask>>;
+  std::vector<AnnotatedDecodeTask> pending_image_tasks_;
 
-  using LayerCountMap = base::hash_map<int, int>;
-  LayerCountMap used_layer_counts_;
+  using AnnotatedDecodedImage =
+      std::pair<ImageKey, scoped_refptr<DecodedImage>>;
+  std::deque<AnnotatedDecodedImage> decoded_images_;
+  base::Lock lock_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_IMAGE_DECODE_CONTROLLER_H_