cc: Pass priority rect information from iterators to 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 194 matching lines @@
       const gfx::Rect& bounding_rect,
       RectExpansionCache* cache);
 
  protected:
   friend class CoverageIterator;
   friend class PrioritizedTile;
   friend class TilingSetRasterQueueAll;
   friend class TilingSetRasterQueueRequired;
   friend class TilingSetEvictionQueue;
 
+  // PENDING VISIBLE RECT refers to the visible rect that will become current
+  // upon activation (ie, the pending tree's visible rect). Tiles in this
+  // region that are not part of the current visible rect are all handled
+  // here. Note that when processing a pending tree, this rect is the same as
+  // the visible rect so no tiles are processed in this case.
+  enum PriorityRectType {
+    VISIBLE_RECT,
+    PENDING_VISIBLE_RECT,
+    SKEWPORT_RECT,
+    SOON_BORDER_RECT,
+    EVENTUALLY_RECT
+  };
+
   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;
   };
 
   PictureLayerTiling(WhichTree tree,
                      float contents_scale,
@@ skipping 40 matching lines @@
     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 UpdateRequiredStatesOnTile(Tile* tile) const;
-  PrioritizedTile MakePrioritizedTile(Tile* tile) const;
-  TilePriority ComputePriorityForTile(const Tile* tile) const;
+  PrioritizedTile MakePrioritizedTile(
+      Tile* tile,
+      PriorityRectType priority_rect_type) const;
+  TilePriority ComputePriorityForTile(
+      const Tile* tile,
+      PriorityRectType priority_rect_type) const;
+  PriorityRectType ComputePriorityRectTypeForTile(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 57 matching lines @@
 
  private:
   DISALLOW_ASSIGN(PictureLayerTiling);
 
   RectExpansionCache expansion_cache_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_PICTURE_LAYER_TILING_H_