cc: Remove tile sharing from tilings.

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 <map>
 #include <utility>
 #include <vector>
@@ skipping 40 matching lines @@
   virtual bool RequiresHighResToDraw() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
 };
 
 class CC_EXPORT PictureLayerTiling {
  public:
   static const int kBorderTexels = 1;
 
+  PictureLayerTilingClient* client() const { return client_; }
   ~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);
 
   void SetRasterSourceAndResize(scoped_refptr<RasterSource> raster_source);
   void Invalidate(const Region& layer_invalidation);
   void SetRasterSourceOnTiles();
   void CreateMissingTilesInLiveTilesRect();
+  void TakeTilesAndPropertiesFrom(PictureLayerTiling* pending_twin,
+                                  const Region& layer_invalidation);
 
-  void CloneTilesAndPropertiesFrom(const PictureLayerTiling& twin_tiling);
+  bool IsTileRequiredForActivation(const Tile* tile) const;
+  bool IsTileRequiredForDraw(const Tile* tile) const;
 
   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;
   }
 
   RasterSource* raster_source() const { return raster_source_.get(); }
   gfx::Size tiling_size() const { return tiling_data_.tiling_size(); }
   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_; }
   const TilingData* tiling_data() const { return &tiling_data_; }
 
   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();
   }
 
+  bool has_tiles() const { return !tiles_.empty(); }
+
+  // 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_);
     current_occlusion_in_layer_space_ =
         Occlusion(gfx::Transform(),
                   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_;
-  }
   void VerifyAllTilesHaveCurrentRasterSource() 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,
@@ skipping 54 matching lines @@
     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 visible_rect_history_[0].frame_time_in_seconds != 0.0;
-  }
-
  protected:
   friend class CoverageIterator;
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
   typedef std::pair<int, int> TileMapKey;
   typedef base::hash_map<TileMapKey, scoped_refptr<Tile>> TileMap;
 
   struct FrameVisibleRect {
     gfx::Rect visible_rect_in_content_space;
     double frame_time_in_seconds = 0.0;
   };
 
   PictureLayerTiling(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);
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   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 TilingMatchesTileIndices(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
   // 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;
 
   // 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(
       double frame_time_in_seconds,
       const gfx::Rect& viewport_in_layer_space) {
     return frame_time_in_seconds !=
                visible_rect_history_[0].frame_time_in_seconds ||
            viewport_in_layer_space != last_viewport_in_layer_space_;
   }
   void UpdateVisibleRectHistory(
       double frame_time_in_seconds,
       const gfx::Rect& visible_rect_in_content_space) {
     visible_rect_history_[1] = visible_rect_history_[0];
     visible_rect_history_[0].frame_time_in_seconds = frame_time_in_seconds;
     visible_rect_history_[0].visible_rect_in_content_space =
         visible_rect_in_content_space;
     // If we don't have a second history item, set it to the most recent one.
     if (visible_rect_history_[1].frame_time_in_seconds == 0.0)
       visible_rect_history_[1] = visible_rect_history_[0];
   }
+  bool IsTileOccludedOnCurrentTree(const Tile* tile) const;
+  bool ShouldCreateTileAt(int i, int j) const;
+  bool IsTileOccluded(const Tile* tile) const;
+  void UpdateTileAndTwinPriority(Tile* tile) const;
+  TilePriority ComputePriorityForTile(const Tile* tile) 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_;
+  }
+  gfx::Rect pending_visible_rect() const {
+    const PictureLayerTiling* pending_tiling =
+        client_->GetTree() == ACTIVE_TREE
+            ? client_->GetPendingOrActiveTwinTiling(this)
+            : this;
+    if (pending_tiling)
+      return pending_tiling->current_visible_rect();
+    return gfx::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_;
+  }
+  bool has_ever_been_updated() const {
+    return visible_rect_history_[0].frame_time_in_seconds != 0.0;
+  }
+  void RemoveTilesInRegion(const Region& layer_region, bool recreate_tiles);
 
   const size_t max_tiles_for_interest_area_;
   const float skewport_target_time_in_seconds_;
   const int skewport_extrapolation_limit_in_content_pixels_;
 
   // Given properties.
   const float contents_scale_;
   PictureLayerTilingClient* const client_;
   scoped_refptr<RasterSource> raster_source_;
   TileResolution resolution_;
@@ skipping 25 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_