cc: Optimize decode scheduling for checker-images.

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 790 matching lines @@
       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;
 }
 
+bool PictureLayerTiling::ShouldDecodeCheckeredImagesForTile(

[vmpstr, 2017/04/20 20:59:32]

If we did end up having images on a tile earlier than we do now, then a lot of
this work could be skipped for tiles with no images at all.. Just a thought for
possible future improvements.

[Khushal, 2017/04/20 21:54:22]

May we could store an enum on Tile indicating whether it has been analyzed for
images and if it has any. This will at least avoid this for repeated runs on the
same tile.

+    const Tile* tile) const {
+  // If this is the pending tree and the tile is not occluded, any checkered
+  // images on this tile should be decoded.
+  if (tree_ == PENDING_TREE)
+    return !IsTileOccludedOnCurrentTree(tile);
+
+  DCHECK_EQ(tree_, ACTIVE_TREE);
+  const PictureLayerTiling* pending_twin =
+      client_->GetPendingOrActiveTwinTiling(this);
+
+  // If we don't have a pending twin, then 2 cases are possible. Either we don't
+  // have a pending tree, in which case we should be decoding images for tiles
+  // which are unoccluded.
+  // If we do have a pending tree, then not having a twin implies that this
+  // tiling will be evicted upon activation. TODO(khushalsagar): Plumb this
+  // information here and return false for this case.
+  if (!pending_twin)
+    return !IsTileOccludedOnCurrentTree(tile);
+
+  // If the tile will be replaced upon activation, then we don't need to process
+  // it for checkered images. Since once the pending tree is activated, it is
+  // the new active tree's content that we will invalidate and replace once the
+  // decode finishes.
+  if (!TilingMatchesTileIndices(pending_twin) ||
+      pending_twin->TileAt(tile->tiling_i_index(), tile->tiling_j_index())) {
+    return false;
+  }
+
+  // Ask the pending twin if this tile will become occluded upon activation.
+  return !pending_twin->IsTileOccludedOnCurrentTree(tile);
+}
+
 void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const {
   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()))
       << "Recording rect: "
       << EnclosingLayerRectFromContentsRect(tile->content_rect()).ToString();
 
   UpdateRequiredStatesOnTile(tile);
   const auto& tile_priority = ComputePriorityForTile(tile, priority_rect_type);
   DCHECK((!tile->required_for_activation() && !tile->required_for_draw()) ||
          tile_priority.priority_bin == TilePriority::NOW ||
          !client_->HasValidTilePriorities());
 
   // 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);
+                         process_for_images_only,
+                         ShouldDecodeCheckeredImagesForTile(tile));
 }
 
 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();
     PrioritizedTile prioritized_tile =
         MakePrioritizedTile(tile, ComputePriorityRectTypeForTile(tile));
     result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
@@ skipping 99 matching lines @@
   return ToEnclosingRect(raster_transform_.MapRect(gfx::RectF(layer_rect)));
 }
 
 gfx::Rect PictureLayerTiling::EnclosingLayerRectFromContentsRect(
     const gfx::Rect& contents_rect) const {
   return ToEnclosingRect(
       raster_transform_.InverseMapRect(gfx::RectF(contents_rect)));
 }
 
 }  // namespace cc