cc: Explicitly invalidate all dropped recordings on the main thread.

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>
 
@@ skipping 120 matching lines @@
        iter;
        ++iter) {
     TileMapKey key = iter.index();
     TileMap::iterator find = tiles_.find(key);
     if (find != tiles_.end())
       continue;
     CreateTile(key.first, key.second, twin_tiling);
   }
 }
 
-void PictureLayerTiling::SetLayerBounds(const gfx::Size& layer_bounds) {
-  if (layer_bounds_ == layer_bounds)
-    return;
-
-  DCHECK(!layer_bounds.IsEmpty());
+void PictureLayerTiling::UpdateTilesToCurrentPile(
+    const Region& layer_invalidation,
+    const gfx::Size& new_layer_bounds) {
+  DCHECK(!new_layer_bounds.IsEmpty());
 
   gfx::Size old_layer_bounds = layer_bounds_;
-  layer_bounds_ = layer_bounds;
+  layer_bounds_ = new_layer_bounds;
+
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds_, contents_scale_));
+  gfx::Size tile_size = tiling_data_.max_texture_size();
 
-  gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
-  if (tile_size != tiling_data_.max_texture_size()) {
+  if (layer_bounds_ != old_layer_bounds) {
+    // Drop tiles outside the new layer bounds if the layer shrank.
+    SetLiveTilesRect(
+        gfx::IntersectRects(live_tiles_rect_, gfx::Rect(content_bounds)));
     tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
-    tiling_data_.SetMaxTextureSize(tile_size);
-    Reset();
-    return;
+    tile_size = client_->CalculateTileSize(content_bounds);
   }
 
-  // Any tiles outside our new bounds are invalid and should be dropped.
-  gfx::Rect bounded_live_tiles_rect(live_tiles_rect_);
-  bounded_live_tiles_rect.Intersect(gfx::Rect(content_bounds));
-  SetLiveTilesRect(bounded_live_tiles_rect);
-  tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
+  if (tile_size != tiling_data_.max_texture_size()) {
+    tiling_data_.SetMaxTextureSize(tile_size);
+    // When the tile size changes, the TilingData positions no longer work
+    // as valid keys to the TileMap, so just drop all tiles.
+    Reset();
+  } else {
+    Invalidate(layer_invalidation);
+  }
 
-  // Create tiles for newly exposed areas.
-  Region layer_region((gfx::Rect(layer_bounds_)));
-  layer_region.Subtract(gfx::Rect(old_layer_bounds));
-  Invalidate(layer_region);
-}
-
-void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_region) {
-  DoInvalidate(layer_region, false /* recreate_tiles */);
+  PicturePileImpl* pile = client_->GetPile();
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    it->second->set_picture_pile(pile);
 }
 
 void PictureLayerTiling::Invalidate(const Region& layer_region) {
-  DoInvalidate(layer_region, true /* recreate_tiles */);
-}
-
-void PictureLayerTiling::DoInvalidate(const Region& layer_region,
-                                      bool recreate_tiles) {
   std::vector<TileMapKey> new_tile_keys;
-  gfx::Rect expanded_live_tiles_rect(
-      tiling_data_.ExpandRectToTileBoundsWithBorders(live_tiles_rect_));
+  // TODO(danakj): What we really want is to ignore border pixels that intersect
+  // the rect when choosing which tiles it covers, then expand to those tiles
+  // plus their border pixels.
+  gfx::Rect expanded_live_tiles_rect =
+      tiling_data_.ExpandRectToTileBounds(live_tiles_rect_);
   for (Region::Iterator iter(layer_region); iter.has_rect(); iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     gfx::Rect content_rect =
         gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
     // Avoid needless work by not bothering to invalidate where there aren't
     // tiles.
     content_rect.Intersect(expanded_live_tiles_rect);
     if (content_rect.IsEmpty())
       continue;
     bool include_borders = true;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
       TileMapKey key(iter.index());
       TileMap::iterator find = tiles_.find(key);
       if (find == tiles_.end())
         continue;
       tiles_.erase(find);
-      if (recreate_tiles)
-        new_tile_keys.push_back(key);
+      new_tile_keys.push_back(key);
     }
   }
 
-  if (recreate_tiles) {
-    const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
-    for (size_t i = 0; i < new_tile_keys.size(); ++i)
+  if (!new_tile_keys.empty()) {
+    for (size_t i = 0; i < new_tile_keys.size(); ++i) {
+      // Don't try to share a tile with the twin layer, it's been invalidated so
+      // we have to make our own tile here.
+      PictureLayerTiling* twin_tiling = NULL;
       CreateTile(new_tile_keys[i].first, new_tile_keys[i].second, twin_tiling);
+    }
   }
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
@@ skipping 392 matching lines @@
     // Tile holds a ref onto a picture pile. If the tile never gets invalidated
     // and recreated, then that picture pile ref could exist indefinitely.  To
     // prevent this, ask the client to update the pile to its own ref.  This
     // will cause PicturePileImpls and their clones to get deleted once the
     // corresponding PictureLayerImpl and any in flight raster jobs go out of
     // scope.
     it->second->set_picture_pile(active_pile);
   }
 }
 
-void PictureLayerTiling::UpdateTilesToCurrentPile() {
-  PicturePileImpl* pile = client_->GetPile();
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->set_picture_pile(pile);
-  }
-}
-
 scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   state->Set("tiling_rect", MathUtil::AsValue(TilingRect()).release());
   return state.PassAs<base::Value>();
 }
 
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
@@ skipping 331 matching lines @@
   tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
   tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
   is_valid_ = true;
   if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
       !(*tile_iterator_)->HasResources()) {
     ++(*this);
   }
 }
 
 }  // namespace cc