Makes tile-creation lazy

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 16 matching lines @@
  public:
   // Create a tile at the given content_rect (in the contents scale of the
   // tiling) This might return null if the client cannot create such a tile.
   virtual scoped_refptr<Tile> CreateTile(
     PictureLayerTiling* tiling,
     gfx::Rect content_rect) = 0;
   virtual void UpdatePile(Tile* tile) = 0;
   virtual gfx::Size CalculateTileSize(
     gfx::Size current_tile_size,
     gfx::Size content_bounds) = 0;
+  virtual const Region* GetInvalidation() = 0;
+  virtual const PictureLayerTiling* GetTwinTiling(
+      const PictureLayerTiling* tiling) = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   ~PictureLayerTiling();
 
   // Create a tiling with no tiles.  CreateTiles must be called to add some.
   static scoped_ptr<PictureLayerTiling> Create(float contents_scale);
   scoped_ptr<PictureLayerTiling> Clone() const;
 
   gfx::Size layer_bounds() const { return layer_bounds_; }
   void SetLayerBounds(gfx::Size layer_bounds);
-  void Invalidate(const Region& layer_invalidation);
 
   // Add any tiles that intersect with |layer_rect|.  If any tiles already
   // exist, then this leaves them as-is.
-  void CreateTilesFromLayerRect(gfx::Rect layer_rect);
 
   void SetClient(PictureLayerTilingClient* client);
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
 
   gfx::Rect ContentRect() const;
   gfx::SizeF ContentSizeF() const;
   float contents_scale() const { return contents_scale_; }
 
   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);
     return all_tiles;
   }
 
-  static gfx::Rect ExpandRectEquallyToAreaBoundedBy(
-      gfx::Rect starting_rect,
-      int64 target_area,
-      gfx::Rect bounding_rect);
-
   // 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 Iterator {
    public:
     Iterator();
     Iterator(const PictureLayerTiling* tiling,
         float dest_scale,
         gfx::Rect rect);
@@ skipping 58 matching lines @@
   void DidBecomeActive();
 
   scoped_ptr<base::Value> AsValue() const;
 
  protected:
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile> > TileMap;
 
   explicit PictureLayerTiling(float contents_scale);
   Tile* TileAt(int, int) const;
-  void CreateTilesFromContentRect(gfx::Rect layer_rect);
   void CreateTile(int i, int j);
 
-  PictureLayerTilingClient* client_;
+  static gfx::Rect ExpandRectEquallyToAreaBoundedBy(
+      gfx::Rect starting_rect,
+      int64 target_area,
+      gfx::Rect bounding_rect);
+
+  // Given properties.
   float contents_scale_;
   gfx::Size layer_bounds_;
-  gfx::Rect last_prioritized_rect_;
-  // It is not legal to have a NULL tile in the tiles_ map.
-  TileMap tiles_;
+  TileResolution resolution_;
+  PictureLayerTilingClient* client_;
+
+  // Internal data.
   TilingData tiling_data_;
-  TileResolution resolution_;
+  TileMap tiles_;  // It is not legal to have a NULL tile in the tiles_ map.
+
+  // State saved for computing velocities based upon finite differences.
+  gfx::Rect interest_rect_;

[enne (OOO), 2013/03/29 20:50:58]

Can you call this last_interest_rect_ to match the other two variables?

[whunt, 2013/03/29 21:52:04]

I *can*, it doesn't quite follow the same semantics though.  The two "last_"
variables are used for finite differences for the sake of calculating motion. 
The "interest_rect_" could really be called "live_tiles_rect", it's used in a
variety of places and set by functions other than UpdateTileProperties.  I don't
think it's appropriate to lump it in with the others.  To be fair, I left it
grouped with them in the definition here and I should move it.

[enne (OOO), 2013/03/29 22:34:20]

By "a variety of places" you mean "can be cleared in SetLayerBounds"?  I think
the tile map and the interest rect are tied together, where they both need to be
updated together.  It's still semantically "the last time you updated the tiles"
for the sake of generating a diff.

   int last_source_frame_number_;
   double last_impl_frame_time_;
 
   friend class Iterator;
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);

[enne (OOO), 2013/03/29 20:50:58]

style nit: DISALLOW_etc goes last in a class declaration.

[whunt, 2013/03/29 21:52:04]

Ahh, okay, this is where it merged in, I'll move it.

+  void ManageTiles(const gfx::Rect& old_interest_rect,
+                   const gfx::Rect& new_interest_rect);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_