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:
+    enum Type { VISIBLE, SKEWPORT, EVENTUALLY };
+
+    TilingRasterTileIterator();
+    TilingRasterTileIterator(PictureLayerTiling* tiling, WhichTree tree);
+    ~TilingRasterTileIterator();
+
+    operator bool() const {
+      return current_tile_ && TileNeedsRaster(current_tile_);
+    }
+    Tile* operator*() { return current_tile_; }
+    Type get_type() const { return type_; }
+
+    TilingRasterTileIterator& operator++();
+
+    bool HasVisibleTiles() const { return type_ == VISIBLE; }

[enne (OOO), 2014/03/06 02:30:45]

unused?

[vmpstr, 2014/03/07 18:22:23]

Removed.

+
+    gfx::Rect TileBounds() const {
+      DCHECK(*this);
+      if (type_ == VISIBLE) {
+        return tiling_->tiling_data_.TileBounds(visible_iterator_.index_x(),
+                                                visible_iterator_.index_y());
+      }
+      return tiling_->tiling_data_.TileBounds(spiral_iterator_.index_x(),
+                                              spiral_iterator_.index_y());
+    }
+
+   private:
+    void AdvancePhase();
+    bool TileNeedsRaster(Tile* tile) const {
+      RasterMode mode = tile->DetermineRasterModeForTree(tree_);
+      return tile->NeedsRasterForMode(mode);
+    };
+
+    PictureLayerTiling* tiling_;
+
+    Type type_;
+    WhichTree tree_;
+
+    Tile* current_tile_;
+    TilingData::Iterator visible_iterator_;
+    TilingData::SpiralDifferenceIterator spiral_iterator_;
+  };
+
   ~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);
   void CreateMissingTilesInLiveTilesRect();
 
   void SetCanUseLCDText(bool can_use_lcd_text);
 
   void SetClient(PictureLayerTilingClient* client);
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
 
   gfx::Rect ContentRect() const;
   gfx::SizeF ContentSizeF() const;
   gfx::Rect live_tiles_rect() const { return live_tiles_rect_; }
   gfx::Size tile_size() const { return tiling_data_.max_texture_size(); }
   float contents_scale() const { return contents_scale_; }
 
+  Tile* TileAt(int i, int j) const {
+    TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
+    return (iter == tiles_.end()) ? NULL : iter->second.get();
+  }
+
   void CreateAllTilesForTesting() {
     SetLiveTilesRect(gfx::Rect(tiling_data_.total_size()));
   }
 
   std::vector<Tile*> AllTilesForTesting() const {
     std::vector<Tile*> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin();
          it != tiles_.end(); ++it)
       all_tiles.push_back(it->second.get());
     return all_tiles;
   }
 
-  Tile* TileAt(int i, int j) const;
-
   // Iterate over all tiles to fill content_rect.  Even if tiles are invalid
   // (i.e. no valid resource) this tiling should still iterate over them.
   // The union of all geometry_rect calls for each element iterated over should
   // exactly equal content_rect and no two geometry_rects should intersect.
   class CC_EXPORT CoverageIterator {
    public:
     CoverageIterator();
     CoverageIterator(const PictureLayerTiling* tiling,
         float dest_scale,
         const gfx::Rect& rect);
@@ skipping 56 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);
+  Tile* 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;
 
   // 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_;
+
+  gfx::Rect current_visible_rect_in_content_space_;

[enne (OOO), 2014/03/06 02:30:45]

I think it'd be cleaner if you just passed them to the iterators explicitly and
didn't store them on the tiling.

[vmpstr, 2014/03/07 18:22:23]

The problem is that these are generated during UpdateTilePriorities. The thing
that will be creating iterators is the layer, which doesn't know about
skewport/eventually rect. It also shouldn't know that, IMHO. 

[enne (OOO), 2014/03/10 21:36:30]

Can you get them off the tiling and pass them to the iterator? There's this
weird kind of timing issue, where when those are updated and when you create the
iterator are intertwined because you're reaching back and getting data off the
tiling that will then change the iterators.  I think having to recreate the
iterators when those rects change seems cleaner.

+  gfx::Rect current_skewport_;
+  gfx::Rect current_eventually_rect_;
 
   friend class CoverageIterator;
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_