cc: Mirror LiveTilesRect and tiles between active and recycled trees.

cc/resources/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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 101 matching lines @@
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_shared(false);
 }
 
 Tile* PictureLayerTiling::CreateTile(int i,
                                      int j,
-                                     const PictureLayerTiling* twin_tiling) {
+                                     const PictureLayerTiling* twin_tiling,
+                                     PictureLayerTiling* recycled_twin) {
+  // Can't have both a (pending or active) twin and a recycled twin tiling.
+  DCHECK_IMPLIES(twin_tiling, !recycled_twin);
+  DCHECK_IMPLIES(recycled_twin, !twin_tiling);
   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());
 
   // Check our twin for a valid tile.
   if (twin_tiling &&
       tiling_data_.max_texture_size() ==
@@ skipping 12 matching lines @@
       }
     }
   }
 
   // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
   if (tile.get()) {
     DCHECK(!tile->is_shared());
     tile->set_tiling_index(i, j);
     tiles_[key] = tile;
+
+    if (recycled_twin) {
+      DCHECK(recycled_twin->tiles_.find(key) == recycled_twin->tiles_.end());
+      // Do what recycled_twin->CreateTile() would do.
+      tile->set_shared(true);
+      recycled_twin->tiles_[key] = tile;

[vmpstr, 2014/12/12 18:01:34]

What happens if this tile is outside of the recycled twin's ltr? That is, when
recycled becomes pending and starts doing work, won't it trip up if it expects
nothing but gets something?

[danakj, 2014/12/12 18:02:48]

This is a good question.. we should maybe set the LTR on the recycled tiling
when we set it on the active?

+    }
   }
   eviction_tiles_cache_valid_ = false;
   return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
+  // There is no recycled twin during commit from the main thread which is when
+  // this occurs.
+  PictureLayerTiling* null_recycled_twin = nullptr;
+  DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
   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;
-    CreateTile(key.first, key.second, twin_tiling);
+    CreateTile(key.first, key.second, twin_tiling, null_recycled_twin);
   }
 
   VerifyLiveTilesRect();
 }
 
 void PictureLayerTiling::CloneTilesAndPropertiesFrom(
     const PictureLayerTiling& twin_tiling) {
   DCHECK_EQ(&twin_tiling, client_->GetPendingOrActiveTwinTiling(this));
 
   Resize(twin_tiling.layer_bounds_);
@@ skipping 12 matching lines @@
     Tile* tile = tile_map_pair.second.get();
     if (!tile->is_shared())
       to_remove.push_back(key);
   }
   // The recycled twin does not exist since there is a pending twin (which is
   // |twin_tiling|).
   PictureLayerTiling* null_recycled_twin = nullptr;
   DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
   for (const auto& key : to_remove) {
     RemoveTileAt(key.first, key.second, null_recycled_twin);
-    CreateTile(key.first, key.second, &twin_tiling);
+    CreateTile(key.first, key.second, &twin_tiling, null_recycled_twin);
+  }
+
+  // Create any missing tiles from the |twin_tiling|.

[danakj, 2014/12/11 23:38:08]

I should write a test for this change: Activate with missing recordings, then
commit with those recordings filled in and the same LiveTilesRect

+  for (const auto& tile_map_pair : twin_tiling.tiles_) {
+    TileMapKey key = tile_map_pair.first;
+    Tile* tile = tile_map_pair.second.get();
+    if (!tile->is_shared())
+      CreateTile(key.first, key.second, &twin_tiling, null_recycled_twin);
   }
 
   DCHECK_EQ(twin_tiling.tiles_.size(), tiles_.size());
 #if DCHECK_IS_ON
   for (const auto& tile_map_pair : tiles_)
     DCHECK(tile_map_pair.second->is_shared());
+  VerifyLiveTilesRect();
 #endif
 
   UpdateTilePriorityRects(twin_tiling.current_content_to_screen_scale_,
                           twin_tiling.current_visible_rect_,
                           twin_tiling.current_skewport_rect_,
                           twin_tiling.current_soon_border_rect_,
                           twin_tiling.current_eventually_rect_,
                           twin_tiling.current_occlusion_in_layer_space_);
 }
 
@@ skipping 48 matching lines @@
   int after_bottom = -1;
   if (!live_tiles_rect_.IsEmpty()) {
     after_right =
         tiling_data_.TileXIndexFromSrcCoord(live_tiles_rect_.right() - 1);
     after_bottom =
         tiling_data_.TileYIndexFromSrcCoord(live_tiles_rect_.bottom() - 1);
   }
 
   // There is no recycled twin since this is run on the pending tiling
   // during commit, and on the active tree during activate.
-  PictureLayerTiling* recycled_twin = NULL;
-  DCHECK_EQ(recycled_twin, client_->GetRecycledTwinTiling(this));
+  PictureLayerTiling* null_recycled_twin = nullptr;
+  DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
 
   // Drop tiles outside the new layer bounds if the layer shrank.
   for (int i = after_right + 1; i <= before_right; ++i) {
     for (int j = before_top; j <= before_bottom; ++j)
-      RemoveTileAt(i, j, recycled_twin);
+      RemoveTileAt(i, j, null_recycled_twin);
   }
   for (int i = before_left; i <= after_right; ++i) {
     for (int j = after_bottom + 1; j <= before_bottom; ++j)
-      RemoveTileAt(i, j, recycled_twin);
+      RemoveTileAt(i, j, null_recycled_twin);
   }
 
   // If the layer grew, the live_tiles_rect_ is not changed, but a new row
   // and/or column of tiles may now exist inside the same live_tiles_rect_.
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
   if (after_right > before_right) {
     DCHECK_EQ(after_right, before_right + 1);
     for (int j = before_top; j <= after_bottom; ++j)
-      CreateTile(after_right, j, twin_tiling);
+      CreateTile(after_right, j, twin_tiling, null_recycled_twin);
   }
   if (after_bottom > before_bottom) {
     DCHECK_EQ(after_bottom, before_bottom + 1);
     for (int i = before_left; i <= before_right; ++i)
-      CreateTile(i, after_bottom, twin_tiling);
+      CreateTile(i, after_bottom, twin_tiling, null_recycled_twin);
   }
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
   if (live_tiles_rect_.IsEmpty())
     return;
   std::vector<TileMapKey> new_tile_keys;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectIgnoringBordersToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_invalidation); iter.has_rect();
@@ skipping 13 matching lines @@
       continue;
     // Since the content_rect includes border pixels already, don't include
     // borders when iterating to avoid double counting them.
     bool include_borders = false;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
       // There is no recycled twin for the pending tree during commit, or for
       // the active tree during activation.
-      PictureLayerTiling* null_recycled_twin = NULL;
+      PictureLayerTiling* null_recycled_twin = nullptr;
       DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
       if (RemoveTileAt(iter.index_x(), iter.index_y(), null_recycled_twin))
         new_tile_keys.push_back(iter.index());
     }
   }
 
   if (!new_tile_keys.empty()) {
     // During commit from the main thread, invalidations can never be shared
     // with the active tree since the active tree has different content there.
-    const PictureLayerTiling* twin_tiling = nullptr;
+    // And when invalidating an active-tree tiling, it means there was no
+    // pending tiling to clone from.
+    const PictureLayerTiling* null_twin_tiling = nullptr;
+    PictureLayerTiling* null_recycled_twin = nullptr;
+    DCHECK_EQ(null_recycled_twin, client_->GetRecycledTwinTiling(this));
     for (size_t i = 0; i < new_tile_keys.size(); ++i) {
-      CreateTile(new_tile_keys[i].first, new_tile_keys[i].second, twin_tiling);
+      CreateTile(new_tile_keys[i].first, new_tile_keys[i].second,
+                 null_twin_tiling, null_recycled_twin);
     }
   }
 }
 
 void PictureLayerTiling::SetRasterSource(
     scoped_refptr<RasterSource> raster_source) {
   // Shared (ie. non-invalidated) tiles on the pending tree are updated to use
   // the new raster source. When this raster source is activated, the raster
   // source will remain valid for shared tiles in the active tree.
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
@@ skipping 154 matching lines @@
 bool PictureLayerTiling::RemoveTileAt(int i,
                                       int j,
                                       PictureLayerTiling* recycled_twin) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   found->second->set_shared(false);
   tiles_.erase(found);
   eviction_tiles_cache_valid_ = false;
   if (recycled_twin) {
-    // Recycled twin does not also have a recycled twin, so pass NULL.
-    recycled_twin->RemoveTileAt(i, j, NULL);
+    // Recycled twin does not also have a recycled twin, so pass null.
+    recycled_twin->RemoveTileAt(i, j, nullptr);
   }
   return true;
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   PictureLayerTiling* recycled_twin = client_->GetRecycledTwinTiling(this);
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     it->second->set_shared(false);
     if (recycled_twin)
-      recycled_twin->RemoveTileAt(it->first.first, it->first.second, NULL);
+      recycled_twin->RemoveTileAt(it->first.first, it->first.second, nullptr);
   }
   tiles_.clear();
   eviction_tiles_cache_valid_ = false;
 }
 
 gfx::Rect PictureLayerTiling::ComputeSkewport(
     double current_frame_time_in_seconds,
     const gfx::Rect& visible_rect_in_content_space) const {
   gfx::Rect skewport = visible_rect_in_content_space;
   if (last_impl_frame_time_in_seconds_ == 0.0)
@@ skipping 142 matching lines @@
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
 
   // 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());
-    CreateTile(key.first, key.second, twin_tiling);
+    CreateTile(key.first, key.second, twin_tiling, recycled_twin);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
   VerifyLiveTilesRect();
 }
 
-void PictureLayerTiling::VerifyLiveTilesRect() {
+void PictureLayerTiling::VerifyLiveTilesRect() const {
 #if DCHECK_IS_ON
-  for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+  for (auto it = tiles_.begin(); it != tiles_.end(); ++it) {
     if (!it->second.get())
       continue;
     DCHECK(it->first.first < tiling_data_.num_tiles_x())
         << this << " " << it->first.first << "," << it->first.second
         << " num_tiles_x " << tiling_data_.num_tiles_x() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
     DCHECK(it->first.second < tiling_data_.num_tiles_y())
         << this << " " << it->first.first << "," << it->first.second
         << " num_tiles_y " << tiling_data_.num_tiles_y() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
@@ skipping 546 matching lines @@
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 }  // namespace cc