cc: Separate the priority from the tile and put in new PrioritizedTile

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 11 matching lines @@
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }
 }
 
 namespace cc {
 
 class PictureLayerTiling;
+class PrioritizedTile;
 class RasterSource;
 
 class CC_EXPORT PictureLayerTilingClient {
  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 ScopedTilePtr CreateTile(float contents_scale,
                                    const gfx::Rect& content_rect) = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
@@ skipping 64 matching lines @@
   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);
     return all_tiles;
   }
-  void UpdateAllTilePrioritiesForTesting() {
-    for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
-      UpdateTilePriority(it->second);
+
+  void UpdateAllRequiredStateForTesting() {
+    for (const auto& key_tile_pair : tiles_)
+      UpdateRequiredStatesOnTile(key_tile_pair.second);
   }
+  std::map<const Tile*, PrioritizedTile>
+  UpdateAndGetAllPrioritizedTilesForTesting();
+
   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_;
@@ skipping 68 matching lines @@
 
   static
   gfx::Rect ExpandRectEquallyToAreaBoundedBy(
       const gfx::Rect& starting_rect,
       int64 target_area,
       const gfx::Rect& bounding_rect,
       RectExpansionCache* cache);
 
  protected:
   friend class CoverageIterator;
+  friend class PrioritizedTile;
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
   using TileMapKey = std::pair<int, int>;
   using TileMap = base::ScopedPtrHashMap<TileMapKey, ScopedTilePtr>;
 
   struct FrameVisibleRect {
     gfx::Rect visible_rect_in_content_space;
     double frame_time_in_seconds = 0.0;
@@ skipping 43 matching lines @@
     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 UpdateTilePriority(Tile* tile) const;
+  void UpdateRequiredStatesOnTile(Tile* tile) const;
+  PrioritizedTile MakePrioritizedTile(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_;
@@ skipping 58 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_