cc: Start using raster/eviction iterators.

cc/resources/tile_manager.h

Index: cc/resources/tile_manager.h
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index 5ad80910f8e8aed434edc19e2a04571ce3d62781..cf33c02dc51ffa214302aa729cc56c76035e6329 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -17,22 +17,25 @@
 #include "cc/base/ref_counted_managed.h"
 #include "cc/base/unique_notifier.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
-#include "cc/layers/picture_layer_impl.h"
+#include "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/managed_tile_state.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/prioritized_tile_set.h"
+#include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/rasterizer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 
 namespace cc {
+class PictureLayerImpl;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
  public:
   // Returns the set of layers that the tile manager should consider for raster.
-  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() = 0;
+  // TODO(vmpstr): Change the way we determine if we are ready to activate, so
+  // that this can be removed.
+  virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() const = 0;
 
   // Called when all tiles marked as required for activation are ready to draw.
   virtual void NotifyReadyToActivate() = 0;
@@ -44,6 +47,20 @@ class CC_EXPORT TileManagerClient {
   // - Tile marked for on-demand raster.
   virtual void NotifyTileStateChanged(const Tile* tile) = 0;
 
+  // Given an empty raster tile priority queue, this will build a priority queue
+  // that will return tiles in order in which they should be rasterized. Note
+  // that if the queue is an object that was built before,
+  // RasterTilePriorityQueue::Reset must be called on it before this function.
+  virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
+                                TreePriority tree_priority) = 0;
+
+  // Given an empty eviction tile priority queue, this will build a priority
+  // queue that will return tiles in order in which they should be evicted. Note
+  // that if the queue is an object that was built before,
+  // EvictionTilePriorityQueue::Reset must be called on it before this function.
+  virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
+                                  TreePriority tree_priority) = 0;
+
  protected:
   virtual ~TileManagerClient() {}
 };
@@ -64,105 +81,6 @@ scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
 class CC_EXPORT TileManager : public RasterizerClient,
                               public RefCountedManager<Tile> {
  public:
-  struct CC_EXPORT PairedPictureLayer {
-    PairedPictureLayer();
-    ~PairedPictureLayer();
-
-    PictureLayerImpl* active_layer;
-    PictureLayerImpl* pending_layer;
-  };
-
-  class CC_EXPORT RasterTileIterator {
-   public:
-    RasterTileIterator(TileManager* tile_manager, TreePriority tree_priority);
-    ~RasterTileIterator();
-
-    RasterTileIterator& operator++();
-    operator bool() const;
-    Tile* operator*();
-
-   private:
-    struct PairedPictureLayerIterator {
-      PairedPictureLayerIterator();
-      ~PairedPictureLayerIterator();
-
-      Tile* PeekTile(TreePriority tree_priority);
-      void PopTile(TreePriority tree_priority);
-
-      std::pair<PictureLayerImpl::LayerRasterTileIterator*, WhichTree>
-          NextTileIterator(TreePriority tree_priority);
-
-      PictureLayerImpl::LayerRasterTileIterator active_iterator;
-      PictureLayerImpl::LayerRasterTileIterator pending_iterator;
-
-      std::vector<Tile*> returned_shared_tiles;
-    };
-
-    class RasterOrderComparator {
-     public:
-      explicit RasterOrderComparator(TreePriority tree_priority);
-
-      bool operator()(PairedPictureLayerIterator* a,
-                      PairedPictureLayerIterator* b) const;
-
-     private:
-      TreePriority tree_priority_;
-    };
-
-    std::vector<PairedPictureLayerIterator> paired_iterators_;
-    std::vector<PairedPictureLayerIterator*> iterator_heap_;
-    TreePriority tree_priority_;
-    RasterOrderComparator comparator_;
-
-    DISALLOW_COPY_AND_ASSIGN(RasterTileIterator);
-  };
-
-  struct CC_EXPORT EvictionTileIterator {
-   public:
-    EvictionTileIterator();
-    EvictionTileIterator(TileManager* tile_manager, TreePriority tree_priority);
-    ~EvictionTileIterator();
-
-    EvictionTileIterator& operator++();
-    operator bool() const;
-    Tile* operator*();
-
-   private:
-    struct PairedPictureLayerIterator {
-      PairedPictureLayerIterator();
-      ~PairedPictureLayerIterator();
-
-      Tile* PeekTile(TreePriority tree_priority);
-      void PopTile(TreePriority tree_priority);
-
-      PictureLayerImpl::LayerEvictionTileIterator* NextTileIterator(
-          TreePriority tree_priority);
-
-      PictureLayerImpl::LayerEvictionTileIterator active_iterator;
-      PictureLayerImpl::LayerEvictionTileIterator pending_iterator;
-
-      std::vector<Tile*> returned_shared_tiles;
-    };
-
-    class EvictionOrderComparator {
-     public:
-      explicit EvictionOrderComparator(TreePriority tree_priority);
-
-      bool operator()(PairedPictureLayerIterator* a,
-                      PairedPictureLayerIterator* b) const;
-
-     private:
-      TreePriority tree_priority_;
-    };
-
-    std::vector<PairedPictureLayerIterator> paired_iterators_;
-    std::vector<PairedPictureLayerIterator*> iterator_heap_;
-    TreePriority tree_priority_;
-    EvictionOrderComparator comparator_;
-
-    DISALLOW_COPY_AND_ASSIGN(EvictionTileIterator);
-  };
-
   static scoped_ptr<TileManager> Create(
       TileManagerClient* client,
       base::SequencedTaskRunner* task_runner,
@@ -191,18 +109,14 @@ class CC_EXPORT TileManager : public RasterizerClient,
     return memory_stats_from_last_assign_;
   }
 
-  void GetPairedPictureLayers(std::vector<PairedPictureLayer>* layers) const;
-
   void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
     for (size_t i = 0; i < tiles.size(); ++i) {
       ManagedTileState& mts = tiles[i]->managed_state();
       ManagedTileState::TileVersion& tile_version =
           mts.tile_versions[HIGH_QUALITY_RASTER_MODE];
 
-      tile_version.resource_ = resource_pool_->AcquireResource(gfx::Size(1, 1));
-
-      bytes_releasable_ += BytesConsumedIfAllocated(tiles[i]);
-      ++resources_releasable_;
+      tile_version.resource_ =
+          resource_pool_->AcquireResource(tiles[i]->size());
     }
   }
 
@@ -217,12 +131,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   void SetGlobalStateForTesting(
       const GlobalStateThatImpactsTilePriority& state) {
-    // Soft limit is used for resource pool such that
-    // memory returns to soft limit after going over.
-    if (state != global_state_) {
-      global_state_ = state;
-      prioritized_tiles_dirty_ = true;
-    }
+    global_state_ = state;
   }
 
   void SetRasterizerForTesting(Rasterizer* rasterizer);
@@ -236,13 +145,10 @@ class CC_EXPORT TileManager : public RasterizerClient,
               Rasterizer* rasterizer,
               RenderingStatsInstrumentation* rendering_stats_instrumentation);
 
-  // Methods called by Tile
-  friend class Tile;
-  void DidChangeTilePriority(Tile* tile);
-
   void CleanUpReleasedTiles();
 
   // Overriden from RefCountedManager<Tile>:
+  friend class Tile;
   virtual void Release(Tile* tile) OVERRIDE;
 
   // Overriden from RasterizerClient:
@@ -257,11 +163,30 @@ class CC_EXPORT TileManager : public RasterizerClient,
   virtual void ScheduleTasks(
       const TileVector& tiles_that_need_to_be_rasterized);
 
-  void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles,
-                              TileVector* tiles_that_need_to_be_rasterized);
-  void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
+  void AssignGpuMemoryToTiles(TileVector* tiles_that_need_to_be_rasterized);
 
  private:
+  class MemoryUsage {
+   public:
+    MemoryUsage();
+    MemoryUsage(int64 memory_bytes, int resource_count);
+
+    static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
+    static MemoryUsage FromTile(const Tile* tile);
+
+    MemoryUsage& operator+=(const MemoryUsage& other);
+    MemoryUsage& operator-=(const MemoryUsage& other);
+    MemoryUsage operator-(const MemoryUsage& other);
+
+    bool Exceeds(const MemoryUsage& limit) const;
+
+    int64 memory_bytes() const { return memory_bytes_; }
+
+   private:
+    int64 memory_bytes_;
+    int resource_count_;
+  };
+
   void OnImageDecodeTaskCompleted(int layer_id,
                                   SkPixelRef* pixel_ref,
                                   bool was_canceled);
@@ -271,11 +196,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
                              const PicturePileImpl::Analysis& analysis,
                              bool was_canceled);
 
-  inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
-    return Resource::MemorySizeBytes(tile->size(),
-                                     resource_pool_->resource_format());
-  }
-
   void FreeResourceForTile(Tile* tile, RasterMode mode);
   void FreeResourcesForTile(Tile* tile);
   void FreeUnusedResourcesForTile(Tile* tile);
@@ -283,8 +203,16 @@ class CC_EXPORT TileManager : public RasterizerClient,
   scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
                                                        SkPixelRef* pixel_ref);
   scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
-  void UpdatePrioritizedTileSetIfNeeded();
 
+  bool FreeTileResourcesUntilUsageIsWithinLimit(TilePriorityQueue* queue,
+                                                const MemoryUsage& limit,
+                                                MemoryUsage* usage);
+  bool FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+      TilePriorityQueue* queue,
+      const MemoryUsage& limit,
+      const TilePriority& other_priority,
+      MemoryUsage* usage);
+  bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority);
   bool IsReadyToActivate() const;
   void CheckIfReadyToActivate();
 
@@ -297,16 +225,8 @@ class CC_EXPORT TileManager : public RasterizerClient,
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
   TileMap tiles_;
 
-  PrioritizedTileSet prioritized_tiles_;
-  bool prioritized_tiles_dirty_;
+  bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
 
-  bool all_tiles_that_need_to_be_rasterized_have_memory_;
-  bool all_tiles_required_for_activation_have_memory_;
-
-  size_t bytes_releasable_;
-  size_t resources_releasable_;
-
-  bool ever_exceeded_memory_budget_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
@@ -335,6 +255,9 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   UniqueNotifier ready_to_activate_check_notifier_;
 
+  RasterTilePriorityQueue raster_priority_queue_;
+  EvictionTilePriorityQueue eviction_priority_queue_;
+
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };