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/18 00:20:00]

None of the checks here really care if the tile is checkered imaged. Should this
be named something different?

[Khushal, 2017/04/19 06:16:41]

Answered above.

+    const Tile* tile) const {
+  // If this is the pending tree and the tile is not occluded, it needs to be
+  // decoded for checker-images.

[vmpstr, 2017/04/18 00:20:00]

Tile isn't "decoded", can you rephrase the comment?

[Khushal, 2017/04/19 06:16:41]

Done.

+  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, the tiling may be evicted upon activation,
+  // or we may not have a pending tree. So use the occlusion on the current

[vmpstr, 2017/04/18 00:20:00]

Can you elaborate on this? 

[Khushal, 2017/04/19 06:16:41]

The check is for making sure that we don't process active tree tiles that will
be replaced on activation. Right now if there is no twin tiling, it could either
be that there is no pending tree or that the tiling will be evicted. Still needs
plumbing to differentiate between the 2 cases.

+  // tree.
+  // TODO(khushalsagar): If we have a pending tree but no twin tiling, this tile
+  // will get nuked on activation.
+  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);
+}

[vmpstr, 2017/04/18 00:20:00]

This function sounds very similar to RequiredForActivation type of thing. 

Can you explain (in just codereview) what exactly it's doing and how it's
different? I'm a little hesitant about adding another one of these types of
functions unless it's absolutely necessary. 

[Khushal, 2017/04/19 06:16:41]

Its similar to RequiredForActivation for the part that figures out whether a
tile on the active tree will be replaced on the pending tree. In which case, we
don't require this tile for activation and also we shouldn't need to decode
images for it since it will not be present on the next active tree.

But the other checks concerning |can_require_tiles_for_activation_| and whether
the tile is in the |current_visible_rect_| don't apply. If a tile will not be
replaced, then we only want to check whether it will be occluded after
activation. This part is somewhat similar to IsTileOccluded. Except
IsTileOccluded will also consider tiles unoccluded on the active tree
irrespective of their pending tree state (since these tiles do need to be
rasterized). But for the checkered images, can avoid decoding images for such
tiles.

Do you think this might be a premature optimization and we won't have a lot of
such cases?

+
 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