cc: Fix tile priority inversion in picture layer tiling.

cc/tiles/picture_layer_tiling.cc

 // 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.
 
 #include "cc/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 704 matching lines @@
       return true;
     }
     return pending_twin->IsTileOccludedOnCurrentTree(tile);
   }
   return true;
 }
 
 bool PictureLayerTiling::IsTileOccludedOnCurrentTree(const Tile* tile) const {
   if (!current_occlusion_in_layer_space_.HasOcclusion())
     return false;
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
   gfx::Rect tile_query_rect =
-      gfx::IntersectRects(tile->content_rect(), current_visible_rect_);
+      gfx::IntersectRects(tile_bounds, current_visible_rect_);
   // Explicitly check if the tile is outside the viewport. If so, we need to
   // return false, since occlusion for this tile is unknown.
   if (tile_query_rect.IsEmpty())
     return false;
 
   if (contents_scale_ != 1.f) {
     tile_query_rect =
         gfx::ScaleToEnclosingRect(tile_query_rect, 1.f / contents_scale_);
   }
   return current_occlusion_in_layer_space_.IsOccluded(tile_query_rect);
 }
 
 bool PictureLayerTiling::IsTileRequiredForActivation(const Tile* tile) const {
   if (tree_ == PENDING_TREE) {
     if (!can_require_tiles_for_activation_)
       return false;
 
     if (resolution_ != HIGH_RESOLUTION)
       return false;
 
     if (IsTileOccluded(tile))
       return false;
 
-    bool tile_is_visible =
-        tile->content_rect().Intersects(current_visible_rect_);
+    gfx::Rect tile_bounds =
+        tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
+    bool tile_is_visible = tile_bounds.Intersects(current_visible_rect_);
     if (!tile_is_visible)
       return false;
 
     if (client_->RequiresHighResToDraw())
       return true;
 
     const PictureLayerTiling* active_twin =
         client_->GetPendingOrActiveTwinTiling(this);
     if (!active_twin || !TilingMatchesTileIndices(active_twin))
       return true;
@@ skipping 24 matching lines @@
   return pending_twin->IsTileRequiredForActivation(tile);
 }
 
 bool PictureLayerTiling::IsTileRequiredForDraw(const Tile* tile) const {
   if (tree_ == PENDING_TREE)
     return false;
 
   if (resolution_ != HIGH_RESOLUTION)
     return false;
 
-  bool tile_is_visible = current_visible_rect_.Intersects(tile->content_rect());
+  gfx::Rect tile_bounds =
+      tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
+  bool tile_is_visible = current_visible_rect_.Intersects(tile_bounds);
   if (!tile_is_visible)
     return false;
 
   if (IsTileOccludedOnCurrentTree(tile))
     return false;
   return true;
 }
 
-void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const {
-  DCHECK(tile);
-  tile->set_required_for_activation(IsTileRequiredForActivation(tile));
-  tile->set_required_for_draw(IsTileRequiredForDraw(tile));
-}
-
 PrioritizedTile PictureLayerTiling::MakePrioritizedTile(
     Tile* tile,
     PriorityRectType priority_rect_type) const {
   DCHECK(tile);
   DCHECK(raster_source()->CoversRect(tile->enclosing_layer_rect()))
       << "Tile layer rect: " << tile->enclosing_layer_rect().ToString();
 
   const auto& tile_priority = ComputePriorityForTile(tile, priority_rect_type);
+  bool is_now_bin = tile_priority.priority_bin == TilePriority::NOW;
+  tile->set_required_for_activation(is_now_bin &&

[danakj, 2017/01/30 16:55:18]

I don't see a test checking this code, which appears to be changing to include
the NOW comparison?

[vmpstr, 2017/01/30 19:38:20]

This was just a safeguard that we never have required tiles when we're not in
NOW bin. This shouldn't change behavior, and is tested in iterator tests. I
changed this to be a DCHECK instead.

+                                    IsTileRequiredForActivation(tile));
+  tile->set_required_for_draw(is_now_bin && IsTileRequiredForDraw(tile));
+
   // Note that TileManager will consider this flag but may rasterize the tile
   // anyway (if tile is required for activation for example). We should process
   // the tile for images only if it's further than half of the skewport extent.
   bool process_for_images_only =
       tile_priority.distance_to_visible > min_preraster_distance_ &&
       (tile_priority.distance_to_visible > max_preraster_distance_ ||
        tile_priority.distance_to_visible >
            0.5f * max_skewport_extent_in_screen_space_);
   return PrioritizedTile(tile, this, tile_priority, IsTileOccluded(tile),
                          process_for_images_only);
 }
 
 std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
     Tile* tile = key_tile_pair.second.get();
-    UpdateRequiredStatesOnTile(tile);
     PrioritizedTile prioritized_tile =
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile));
     result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
   }
   return result;
 }
 
 TilePriority PictureLayerTiling::ComputePriorityForTile(
     const Tile* tile,
     PriorityRectType priority_rect_type) const {
@@ skipping 75 matching lines @@
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc