cc: Add tiling raster tile iterators.

cc/resources/picture_layer_tiling.h

 // Copyright 2012 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_RESOURCES_PICTURE_LAYER_TILING_H_
 #define CC_RESOURCES_PICTURE_LAYER_TILING_H_
 
 #include <utility>
 #include <vector>
 
@@ skipping 27 matching lines @@
   virtual size_t GetMaxTilesForInterestArea() const = 0;
   virtual float GetSkewportTargetTimeInSeconds() const = 0;
   virtual int GetSkewportExtrapolationLimitInContentPixels() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
+  class CC_EXPORT TilingRasterTileIterator {
+   public:
+    TilingRasterTileIterator();
+    explicit TilingRasterTileIterator(PictureLayerTiling* tiling);
+    ~TilingRasterTileIterator();
+
+    operator bool() const {
+      return tiling_ && tiling_->RasterTileForPriority(current_index_);
+    }
+    void operator++();
+    Tile* operator*() { return tiling_->RasterTileForPriority(current_index_); }
+
+    bool HasVisibleTiles() const {
+      if (!tiling_)
+        return false;
+      return tiling_->HasVisibleTilesAtOrAfterPriority(current_index_);
+    }
+
+   private:
+    PictureLayerTiling* tiling_;
+    size_t current_index_;
+  };
+
+  class TilingEvictionTileIterator {
+   public:
+    TilingEvictionTileIterator();
+    explicit TilingEvictionTileIterator(PictureLayerTiling* tiling);
+    ~TilingEvictionTileIterator();
+
+    operator bool() const {
+      return tiling_ && tiling_->EvictionTileForPriority(current_index_);
+    }
+    void operator++();
+    Tile* operator*() {
+      return tiling_->EvictionTileForPriority(current_index_);
+    }
+
+   private:
+    PictureLayerTiling* tiling_;
+    size_t current_index_;
+  };
+
   ~PictureLayerTiling();
 
   // Create a tiling with no tiles.  CreateTiles must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(
       float contents_scale,
       const gfx::Size& layer_bounds,
       PictureLayerTilingClient* client);
   gfx::Size layer_bounds() const { return layer_bounds_; }
   void SetLayerBounds(const gfx::Size& layer_bounds);
   void Invalidate(const Region& layer_region);
@@ skipping 94 matching lines @@
   // be called before DidBecomeActive, as it resets the active priority
   // while DidBecomeActive promotes pending priority on a similar set of tiles.
   void DidBecomeRecycled();
 
   void UpdateTilesToCurrentPile();
 
   bool NeedsUpdateForFrameAtTime(double frame_time_in_seconds) {
     return frame_time_in_seconds != last_impl_frame_time_in_seconds_;
   }
 
+  size_t RequiredGPUMemoryInBytes() const;
+
   scoped_ptr<base::Value> AsValue() const;
   size_t GPUMemoryUsageInBytes() const;
 
   struct RectExpansionCache {
     RectExpansionCache();
 
     gfx::Rect previous_start;
     gfx::Rect previous_bounds;
     gfx::Rect previous_result;
     int64 previous_target;
   };
 
   static
   gfx::Rect ExpandRectEquallyToAreaBoundedBy(
       const gfx::Rect& starting_rect,
       int64 target_area,
       const gfx::Rect& bounding_rect,
       RectExpansionCache* cache);
 
   bool has_ever_been_updated() const {
     return last_impl_frame_time_in_seconds_ != 0.0;
   }
 
  protected:
+  friend class TilingRasterTileIterator;
+  friend class TilingEvictionTileIterator;
+
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile> > TileMap;
 
   PictureLayerTiling(float contents_scale,
                      const gfx::Size& layer_bounds,
                      PictureLayerTilingClient* client);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void CreateTile(int i, int j, const PictureLayerTiling* twin_tiling);
 
   // Computes a skewport. The calculation extrapolates the last visible
   // rect and the current visible rect to expand the skewport to where it
   // would be in |skewport_target_time| seconds. Note that the skewport
   // is guaranteed to contain the current visible rect.
   gfx::Rect ComputeSkewport(double current_frame_time_in_seconds,
                             const gfx::Rect& visible_rect_in_content_space)
       const;
 
+  Tile* RasterTileForPriority(size_t priority_index);
+  Tile* EvictionTileForPriority(size_t priority_index);
+  bool HasVisibleTilesAtOrAfterPriority(size_t prioroity_index) const;
+
   // Given properties.
   float contents_scale_;
   gfx::Size layer_bounds_;
   TileResolution resolution_;
   PictureLayerTilingClient* client_;
 
   // Internal data.
   TilingData tiling_data_;
   TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
   gfx::Rect live_tiles_rect_;
 
   // State saved for computing velocities based upon finite differences.
   double last_impl_frame_time_in_seconds_;
-  gfx::RectF last_visible_rect_in_content_space_;
+  gfx::Rect last_visible_rect_in_content_space_;
+
+  // Tile bins used to return tiles in raster and eviction iterators.
+  std::vector<Tile*> visible_tiles_;
+  std::vector<Tile*> skewport_tiles_;
+  bool skewport_tiles_sorted_;
+  std::vector<Tile*> eventually_tiles_;
+  bool eventually_tiles_sorted_;
+  std::vector<Tile*> eviction_tiles_;
+  bool eviction_tiles_sorted_;
+
+  WhichTree last_update_tree_;
 
   friend class CoverageIterator;
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_