cc: Remove tile sharing from tilings.

cc/resources/picture_layer_tiling.h

Index: cc/resources/picture_layer_tiling.h
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index ea258a3084fe3df5afab1c696d6278cab769a773..0927ae9f06881823c6d87caa85a33ae7b2b13cea 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -58,33 +58,30 @@ class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
-  ~PictureLayerTiling();
+  virtual ~PictureLayerTiling();
 
   static float CalculateSoonBorderDistance(
       const gfx::Rect& visible_rect_in_content_space,
       float content_to_screen_scale);
 
-  // Create a tiling with no tiles. CreateTile() must be called to add some.
-  static scoped_ptr<PictureLayerTiling> Create(
-      float contents_scale,
-      scoped_refptr<RasterSource> raster_source,
-      PictureLayerTilingClient* client,
-      size_t max_tiles_for_interest_area,
-      float skewport_target_time_in_seconds,
-      int skewport_extrapolation_limit_in_content_pixels);
+  virtual void SetRasterSourceAndResize(
+      scoped_refptr<RasterSource> raster_source) = 0;
+  virtual void Invalidate(const Region& layer_invalidation) = 0;
+  virtual void SetRasterSourceOnTiles() = 0;

[enne (OOO), 2015/04/02 21:45:34]

This function has some api smell for me.  It's weird that it doesn't take an
argument.  It's weird that it exists alongside SetRasterSourceAndResize.  Maybe
its work should be rolled into something else?

[vmpstr, 2015/04/02 22:33:27]

With unshared tiles, I think this could be done as part of
SetRasterSourceAndResize. 

+  virtual void CreateMissingTilesInLiveTilesRect() = 0;
 
-  void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
-  void Invalidate(const Region& layer_invalidation);
-  void SetRasterSourceOnTiles();
-  void CreateMissingTilesInLiveTilesRect();
+  virtual void TakeTilesAndPropertiesFrom(PictureLayerTiling* pending_twin) = 0;
 
-  void CloneTilesAndPropertiesFrom(const PictureLayerTiling& twin_tiling);
+  virtual bool IsTileOccluded(const Tile* tile) const = 0;
+  virtual bool IsTileRequiredForActivation(const Tile* tile) const = 0;

[enne (OOO), 2015/04/02 21:45:34]

This is weird to me to have base level functions that only one tiling really
implements?

[vmpstr, 2015/04/02 22:33:27]

Well, both trees implement these (aside from TakeTilesAndPropertiesFrom).
IsTileRequiredForDraw for instance just happens to be always false on the
pending tree... Is that the part you mean? Or do you mean the couple of "nothing
to do here" functions? That's just from the fact that I'm trying to treat these
tilings as the same from the tiling set perspective. 

+  virtual bool IsTileRequiredForDraw(const Tile* tile) const = 0;
 
   void set_resolution(TileResolution resolution) { resolution_ = resolution; }
   TileResolution resolution() const { return resolution_; }
   void set_can_require_tiles_for_activation(bool can_require_tiles) {
     can_require_tiles_for_activation_ = can_require_tiles;
   }
+  bool IsActiveTree() const { return client_->GetTree() == ACTIVE_TREE; }
 
   RasterSource* raster_source() const { return raster_source_.get(); }
   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
@@ -94,34 +91,62 @@ class CC_EXPORT PictureLayerTiling {
 
   Tile* TileAt(int i, int j) const {
     TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
-    return (iter == tiles_.end()) ? NULL : iter->second.get();
+    return (iter == tiles_.end()) ? nullptr : iter->second.get();
   }
 
+  void UpdateTileAndTwinPriority(Tile* tile) const;
+  TilePriority ComputePriorityForTile(const Tile* tile) const;
+  void UpdateRequiredStateForTile(Tile* tile, WhichTree tree) const;
+  bool has_visible_rect_tiles() const { return has_visible_rect_tiles_; }
+  bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_; }
+  bool has_soon_border_rect_tiles() const {
+    return has_soon_border_rect_tiles_;
+  }
+  bool has_eventually_rect_tiles() const { return has_eventually_rect_tiles_; }
+
+  const gfx::Rect& current_visible_rect() const {
+    return current_visible_rect_;
+  }
+  const gfx::Rect& pending_visible_rect() const {
+    const PictureLayerTiling* twin =
+        client_->GetTree() == ACTIVE_TREE
+            ? client_->GetPendingOrActiveTwinTiling(this)
+            : this;
+    if (twin)
+      return twin->current_visible_rect();
+    return current_visible_rect();
+  }
+  const gfx::Rect& current_skewport_rect() const {
+    return current_skewport_rect_;
+  }
+  const gfx::Rect& current_soon_border_rect() const {
+    return current_soon_border_rect_;
+  }
+  const gfx::Rect& current_eventually_rect() const {
+    return current_eventually_rect_;
+  }
+
+  // For testing functionality.
   void CreateAllTilesForTesting() {
     SetLiveTilesRect(gfx::Rect(tiling_data_.tiling_size()));
   }
-
   const TilingData& TilingDataForTesting() const { return tiling_data_; }
-
   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;
   }
-
   void UpdateAllTilePrioritiesForTesting() {
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       UpdateTileAndTwinPriority(it->second.get());
   }
-
   std::vector<scoped_refptr<Tile>> AllRefTilesForTesting() const {
     std::vector<scoped_refptr<Tile>> all_tiles;
     for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
       all_tiles.push_back(it->second);
     return all_tiles;
   }
-
   void SetAllTilesOccludedForTesting() {
     gfx::Rect viewport_in_layer_space =
         ScaleToEnclosingRect(current_visible_rect_, 1.0f / contents_scale_);
@@ -130,38 +155,10 @@ class CC_EXPORT PictureLayerTiling {
                   SimpleEnclosedRegion(viewport_in_layer_space),
                   SimpleEnclosedRegion(viewport_in_layer_space));
   }
-
   const gfx::Rect& GetCurrentVisibleRectForTesting() const {
     return current_visible_rect_;
   }
 
-  bool IsTileOccluded(const Tile* tile) const;
-  bool IsTileRequiredForActivationIfVisible(const Tile* tile) const;
-  bool IsTileRequiredForDrawIfVisible(const Tile* tile) const;
-
-  void UpdateTileAndTwinPriority(Tile* tile) const;
-  TilePriority ComputePriorityForTile(const Tile* tile) const;
-  void UpdateRequiredStateForTile(Tile* tile, WhichTree tree) const;
-  bool has_visible_rect_tiles() const { return has_visible_rect_tiles_; }
-  bool has_skewport_rect_tiles() const { return has_skewport_rect_tiles_; }
-  bool has_soon_border_rect_tiles() const {
-    return has_soon_border_rect_tiles_;
-  }
-  bool has_eventually_rect_tiles() const { return has_eventually_rect_tiles_; }
-
-  const gfx::Rect& current_visible_rect() const {
-    return current_visible_rect_;
-  }
-  const gfx::Rect& current_skewport_rect() const {
-    return current_skewport_rect_;
-  }
-  const gfx::Rect& current_soon_border_rect() const {
-    return current_soon_border_rect_;
-  }
-  const gfx::Rect& current_eventually_rect() const {
-    return current_eventually_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
@@ -243,6 +240,8 @@ class CC_EXPORT PictureLayerTiling {
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
+  friend class ActivePictureLayerTiling;
+  friend class PendingPictureLayerTiling;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
@@ -258,14 +257,12 @@ class CC_EXPORT PictureLayerTiling {
                      size_t max_tiles_for_interest_area,
                      float skewport_target_time_in_seconds,
                      int skewport_extrapolation_limit_in_content_pixels);
-  void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
+  virtual void SetLiveTilesRect(const gfx::Rect& live_tiles_rect) = 0;
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
-  Tile* CreateTile(int i,
-                   int j,
-                   const PictureLayerTiling* twin_tiling,
-                   PictureLayerTiling* recycled_twin);
+  Tile* CreateTile(int i, int j);
   // Returns true if the Tile existed and was removed from the tiling.
-  bool RemoveTileAt(int i, int j, PictureLayerTiling* recycled_twin);
+  bool RemoveTileAt(int i, int j);
+  bool TilingMatchesTileIndecies(const PictureLayerTiling* twin) const;
 
   // Computes a skewport. The calculation extrapolates the last visible
   // rect and the current visible rect to expand the skewport to where it
@@ -276,12 +273,12 @@ class CC_EXPORT PictureLayerTiling {
       const;
 
   // Save the required data for computing tile priorities later.
-  void UpdateTilePriorityRects(float content_to_screen_scale_,
-                               const gfx::Rect& visible_rect_in_content_space,
-                               const gfx::Rect& skewport,
-                               const gfx::Rect& soon_border_rect,
-                               const gfx::Rect& eventually_rect,
-                               const Occlusion& occlusion_in_layer_space);
+  void SetTilePriorityRects(float content_to_screen_scale_,
+                            const gfx::Rect& visible_rect_in_content_space,
+                            const gfx::Rect& skewport,
+                            const gfx::Rect& soon_border_rect,
+                            const gfx::Rect& eventually_rect,
+                            const Occlusion& occlusion_in_layer_space);
 
   void UpdateTilePriorityForTree(Tile* tile, WhichTree tree) const;
   bool NeedsUpdateForFrameAtTimeAndViewport(