cc: Pass priority rect information from iterators to tilings.

cc/resources/picture_layer_tiling.cc

Index: cc/resources/picture_layer_tiling.cc
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 015c492dcc8600d711791d76a64d4213efdf90a4..fedf78dc3182d816abd56121bb5d6a91444e82cd 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -809,8 +809,9 @@ bool PictureLayerTiling::IsTileRequiredForDraw(const Tile* tile) const {
   return true;
 }
 
-void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
-  tile->set_priority(ComputePriorityForTile(tile));
+void PictureLayerTiling::UpdateTilePriority(Tile* tile,
+                                            PriorityRect priority_rect) const {
+  tile->set_priority(ComputePriorityForTile(tile, priority_rect));
   tile->set_is_occluded(IsTileOccluded(tile));
   tile->set_required_for_activation(IsTileRequiredForActivation(tile));
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
@@ -824,45 +825,73 @@ void PictureLayerTiling::VerifyAllTilesHaveCurrentRasterSource() const {
 }
 
 TilePriority PictureLayerTiling::ComputePriorityForTile(
-    const Tile* tile) const {
+    const Tile* tile,
+    PriorityRect priority_rect) const {
   // TODO(vmpstr): See if this can be moved to iterators.
   TilePriority::PriorityBin max_tile_priority_bin =
       client_->GetMaxTilePriorityBin();
 
+  DCHECK_EQ(ComputePriorityRectForTile(tile), priority_rect);
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
-  gfx::Rect tile_bounds =
-      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
-  if (max_tile_priority_bin <= TilePriority::NOW &&
-      current_visible_rect_.Intersects(tile_bounds)) {
-    return TilePriority(resolution_, TilePriority::NOW, 0);
-  }
+  TilePriority::PriorityBin priority_bin = max_tile_priority_bin;
 
-  if (max_tile_priority_bin <= TilePriority::SOON &&
-      pending_visible_rect().Intersects(tile_bounds)) {
-    return TilePriority(resolution_, TilePriority::SOON, 0);
+  switch (priority_rect) {
+    case VISIBLE_RECT:
+      return TilePriority(resolution_, tile_priority_bin, 0);
+    case PENDING_VISIBLE_RECT:
+      if (max_tile_priority_bin <= TilePriority::SOON)
+        return TilePriority(resolution_, TilePriority::SOON, 0);
+      priority_bin = TilePriority::EVENTUALLY;
+      break;
+    case SKEWPORT_RECT:
+    case SOON_BORDER_RECT:
+      if (max_tile_priority_bin <= TilePriority::SOON)
+        priority_bin = TilePriority::SOON;
+      break;
+    case EVENTUALLY_RECT:
+      priority_bin = TilePriority::EVENTUALLY;
+      break;
   }
 
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
   DCHECK_GT(current_content_to_screen_scale_, 0.f);
   float distance_to_visible =
       current_visible_rect_.ManhattanInternalDistance(tile_bounds) *
       current_content_to_screen_scale_;
 
-  if (max_tile_priority_bin <= TilePriority::SOON &&
-      (current_soon_border_rect_.Intersects(tile_bounds) ||
-       current_skewport_rect_.Intersects(tile_bounds))) {
-    return TilePriority(resolution_, TilePriority::SOON, distance_to_visible);
-  }
+  return TilePriority(resolution_, priority_bin, distance_to_visible);
+}
+
+PictureLayerTiling::PriorityRect PictureLayerTiling::ComputePriorityRectForTile(

[vmpstr, 2015/05/05 18:04:01]

Is this function only used in DCHECKs and tracing?

[USE eero AT chromium.org, 2015/05/06 12:05:20]

It is used also by TilingSetRasterQueueRequired.

If raster tile priority queue is REQUIRED_FOR_ACTIVATION, TSRQR iterates over
pending visible rect tiles without iterating over visible rect tiles first.
Therefore, some tiles reached while iterating over pending visible rect belongs
to VISIBLE_RECT (instead of PENDING_VISIBLE_RECT). TSRQR uses this function to
differentiate between VISIBLE_RECT and PENDING_VISIBLE_RECT tiles.

+    const Tile* tile) const {
+  DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
+
+  if (current_visible_rect_.Intersects(tile_bounds))
+    return VISIBLE_RECT;
+
+  if (pending_visible_rect().Intersects(tile_bounds))
+    return PENDING_VISIBLE_RECT;
+
+  if (current_skewport_rect_.Intersects(tile_bounds))
+    return SKEWPORT_RECT;
+
+  if (current_soon_border_rect_.Intersects(tile_bounds))
+    return SOON_BORDER_RECT;
 
-  return TilePriority(resolution_, TilePriority::EVENTUALLY,
-                      distance_to_visible);
+  DCHECK(current_eventually_rect_.Intersects(tile_bounds));
+  return EVENTUALLY_RECT;
 }
 
 void PictureLayerTiling::GetAllTilesAndPrioritiesForTracing(
     std::map<const Tile*, TilePriority>* tile_map) const {
   for (const auto& tile_pair : tiles_) {
     const Tile* tile = tile_pair.second.get();
-    const TilePriority& priority = ComputePriorityForTile(tile);
+    const TilePriority& priority =
+        ComputePriorityForTile(tile, ComputePriorityRectForTile(tile));
     // Store combined priority.
     (*tile_map)[tile] = priority;
   }