cc: Do the math for a tile's content rect in layer space once.

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 84 matching lines @@
 float PictureLayerTiling::CalculateSoonBorderDistance(
     const gfx::Rect& visible_rect_in_content_space,
     float content_to_screen_scale) {
   float max_dimension = std::max(visible_rect_in_content_space.width(),
                                  visible_rect_in_content_space.height());
   return std::min(
       kMaxSoonBorderDistanceInScreenPixels / content_to_screen_scale,
       max_dimension * kSoonBorderDistanceViewportPercentage);
 }
 
-Tile* PictureLayerTiling::CreateTile(int i, int j) {
+Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) {
+  const int i = info.tiling_i_index;

[vmpstr, 2015/08/28 21:04:17]

While here and doing this, could you just use info.tiling_index here (type being
TileMapKey or std::pair<int, int>)

[danakj, 2015/08/31 21:12:12]

As per offline convo.. nope. :D This is kinda weird cuz PLT knows the TileMapKey
is a struct, but Tile doesn't..

+  const int j = info.tiling_j_index;
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
-  gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
-  gfx::Rect tile_rect = paint_rect;
-  tile_rect.set_size(tiling_data_.max_texture_size());
-
-  if (!raster_source_->CoversRect(tile_rect, contents_scale_))
+  if (!raster_source_->CoversRect(info.enclosing_layer_rect))
     return nullptr;
 
   all_tiles_done_ = false;
-  ScopedTilePtr tile = client_->CreateTile(contents_scale_, tile_rect);
+  ScopedTilePtr tile = client_->CreateTile(info);
   Tile* raw_ptr = tile.get();
-  tile->set_tiling_index(i, j);
   tiles_.add(key, tile.Pass());
   return raw_ptr;
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* active_twin =
       tree_ == PENDING_TREE ? client_->GetPendingOrActiveTwinTiling(this)
                             : nullptr;
   const Region* invalidation =
       active_twin ? client_->GetPendingInvalidation() : nullptr;
 
   bool include_borders = false;
   for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_,
                                  include_borders);
        iter; ++iter) {
     TileMapKey key(iter.index());
     TileMap::iterator find = tiles_.find(key);
     if (find != tiles_.end())
       continue;
 
-    if (ShouldCreateTileAt(key.index_x, key.index_y)) {
-      Tile* tile = CreateTile(key.index_x, key.index_y);
+    Tile::CreateInfo info = CreateInfoForTile(key.index_x, key.index_y);

[vmpstr, 2015/08/28 21:04:17]

... Then don't expand key here, just pass a key.

+    if (ShouldCreateTileAt(info)) {
+      Tile* tile = CreateTile(info);
 
       // If this is the pending tree, then the active twin tiling may contain
       // the previous content ID of these tiles. In that case, we need only
       // partially raster the tile content.
       if (tile && invalidation && TilingMatchesTileIndices(active_twin)) {
         if (const Tile* old_tile =
                 active_twin->TileAt(key.index_x, key.index_y)) {
           gfx::Rect tile_rect = tile->content_rect();
           gfx::Rect invalidated;
           for (Region::Iterator iter(*invalidation); iter.has_rect();
@@ skipping 110 matching lines @@
       RemoveTileAt(i, j);
   }
   for (int i = before_left; i <= after_right; ++i) {
     for (int j = after_bottom + 1; j <= before_bottom; ++j)
       RemoveTileAt(i, j);
   }
 
   if (after_right > before_right) {
     DCHECK_EQ(after_right, before_right + 1);
     for (int j = before_top; j <= after_bottom; ++j) {
-      if (ShouldCreateTileAt(after_right, j))
-        CreateTile(after_right, j);
+      Tile::CreateInfo info = CreateInfoForTile(after_right, j);
+      if (ShouldCreateTileAt(info))
+        CreateTile(info);
     }
   }
   if (after_bottom > before_bottom) {
     DCHECK_EQ(after_bottom, before_bottom + 1);
     for (int i = before_left; i <= before_right; ++i) {
-      if (ShouldCreateTileAt(i, after_bottom))
-        CreateTile(i, after_bottom);
+      Tile::CreateInfo info = CreateInfoForTile(i, after_bottom);
+      if (ShouldCreateTileAt(info))
+        CreateTile(info);
     }
   }
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
   DCHECK_IMPLIES(tree_ == ACTIVE_TREE,
                  !client_->GetPendingOrActiveTwinTiling(this));
   RemoveTilesInRegion(layer_invalidation, true /* recreate tiles */);
 }
 
@@ skipping 39 matching lines @@
   }
 
   for (const auto& pair : remove_tiles) {
     const TileMapKey& key = pair.first;
     const gfx::Rect& invalid_content_rect = pair.second;
     // TODO(danakj): This old_tile will not exist if we are committing to a
     // pending tree since there is no tile there to remove, which prevents
     // tiles from knowing the invalidation rect and content id. crbug.com/490847
     ScopedTilePtr old_tile = TakeTileAt(key.index_x, key.index_y);
     if (recreate_tiles && old_tile) {
-      if (Tile* tile = CreateTile(key.index_x, key.index_y))
+      Tile::CreateInfo info = CreateInfoForTile(key.index_x, key.index_y);
+      if (Tile* tile = CreateTile(info))
         tile->SetInvalidated(invalid_content_rect, old_tile->id());
     }
   }
 }
 
-bool PictureLayerTiling::ShouldCreateTileAt(int i, int j) const {
+Tile::CreateInfo PictureLayerTiling::CreateInfoForTile(int i, int j) const {
+  gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);

[vmpstr, 2015/08/28 21:04:17]

... And expand here? Wdyt?

+  tile_rect.set_size(tiling_data_.max_texture_size());
+  gfx::Rect enclosing_layer_rect =
+      gfx::ScaleToEnclosingRect(tile_rect, 1.f / contents_scale_);
+  return Tile::CreateInfo(i, j, enclosing_layer_rect, tile_rect,
+                          contents_scale_);
+}
+
+bool PictureLayerTiling::ShouldCreateTileAt(
+    const Tile::CreateInfo& info) const {
+  const int i = info.tiling_i_index;
+  const int j = info.tiling_j_index;
   // Active tree should always create a tile. The reason for this is that active
   // tree represents content that we draw on screen, which means that whenever
   // we check whether a tile should exist somewhere, the answer is yes. This
   // doesn't mean it will actually be created (if raster source doesn't cover
   // the tile for instance). Pending tree, on the other hand, should only be
   // creating tiles that are different from the current active tree, which is
   // represented by the logic in the rest of the function.
   if (tree_ == ACTIVE_TREE)
     return true;
 
   // If the pending tree has no active twin, then it needs to create all tiles.
   const PictureLayerTiling* active_twin =
       client_->GetPendingOrActiveTwinTiling(this);
   if (!active_twin)
     return true;
 
   // Pending tree will override the entire active tree if indices don't match.
   if (!TilingMatchesTileIndices(active_twin))
     return true;
 
-  gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
-  gfx::Rect tile_rect = paint_rect;
-  tile_rect.set_size(tiling_data_.max_texture_size());
-
   // If the active tree can't create a tile, because of its raster source, then
   // the pending tree should create one.
-  if (!active_twin->raster_source()->CoversRect(tile_rect, contents_scale()))
+  if (!active_twin->raster_source()->CoversRect(info.enclosing_layer_rect))
     return true;
 
   const Region* layer_invalidation = client_->GetPendingInvalidation();
-  gfx::Rect layer_rect =
-      gfx::ScaleToEnclosingRect(tile_rect, 1.f / contents_scale());
 
   // If this tile is invalidated, then the pending tree should create one.
-  if (layer_invalidation && layer_invalidation->Intersects(layer_rect))
+  if (layer_invalidation &&
+      layer_invalidation->Intersects(info.enclosing_layer_rect))
     return true;
 
   // If the active tree doesn't have a tile here, but it's in the pending tree's
   // visible rect, then the pending tree should create a tile. This can happen
   // if the pending visible rect is outside of the active tree's live tiles
   // rect. In those situations, we need to block activation until we're ready to
   // display content, which will have to come from the pending tree.
-  if (!active_twin->TileAt(i, j) && current_visible_rect_.Intersects(tile_rect))
+  if (!active_twin->TileAt(i, j) &&
+      current_visible_rect_.Intersects(info.content_rect))
     return true;
 
   // In all other cases, the pending tree doesn't need to create a tile.
   return false;
 }
 
 bool PictureLayerTiling::TilingMatchesTileIndices(
     const PictureLayerTiling* twin) const {
   return tiling_data_.max_texture_size() ==
          twin->tiling_data_.max_texture_size();
@@ skipping 329 matching lines @@
   if (resolution_ == NON_IDEAL_RESOLUTION) {
     live_tiles_rect_.Intersect(new_live_tiles_rect);
     VerifyLiveTilesRect(false);
     return;
   }
 
   // Iterate to allocate new tiles for all regions with newly exposed area.
   for (TilingData::DifferenceIterator iter(&tiling_data_, new_live_tiles_rect,
                                            live_tiles_rect_);
        iter; ++iter) {
-    TileMapKey key(iter.index());
-    if (ShouldCreateTileAt(key.index_x, key.index_y))
-      CreateTile(key.index_x, key.index_y);
+    Tile::CreateInfo info = CreateInfoForTile(iter.index_x(), iter.index_y());
+    if (ShouldCreateTileAt(info))
+      CreateTile(info);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
   VerifyLiveTilesRect(false);
 }
 
 void PictureLayerTiling::VerifyLiveTilesRect(bool is_on_recycle_tree) const {
 #if DCHECK_IS_ON()
   for (auto it = tiles_.begin(); it != tiles_.end(); ++it) {
     if (!it->second)
@@ skipping 130 matching lines @@
 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->content_rect(), tile->contents_scale()))
+  DCHECK(raster_source()->CoversRect(tile->enclosing_layer_rect()))
       << "Recording rect: "
       << gfx::ScaleToEnclosingRect(tile->content_rect(),
-                                   1.f / tile->contents_scale()).ToString();
+                                   1.f / tile->contents_scale())
+             .ToString();
 
   return PrioritizedTile(tile, raster_source(),
                          ComputePriorityForTile(tile, priority_rect_type),
                          IsTileOccluded(tile));
 }
 
 std::map<const Tile*, PrioritizedTile>
 PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const {
   std::map<const Tile*, PrioritizedTile> result;
   for (const auto& key_tile_pair : tiles_) {
@@ skipping 89 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;
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc