cc: Remove invalidated recycle tree tiles on activation.

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 150 matching lines @@
     Reset();
   } else {
     Invalidate(layer_invalidation);
   }
 
   PicturePileImpl* pile = client_->GetPile();
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_picture_pile(pile);
 }
 
+void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_region) {
+  bool recreate_invalidated_tiles = false;
+  DoInvalidate(layer_region, recreate_invalidated_tiles);
+}
+
 void PictureLayerTiling::Invalidate(const Region& layer_region) {
+  bool recreate_invalidated_tiles = true;
+  DoInvalidate(layer_region, recreate_invalidated_tiles);
+}
+
+void PictureLayerTiling::DoInvalidate(const Region& layer_region,
+                                      bool recreate_invalidated_tiles) {
   std::vector<TileMapKey> new_tile_keys;
   gfx::Rect expanded_live_tiles_rect =
       tiling_data_.ExpandRectIgnoringBordersToTileBoundsWithBorders(
           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);
       new_tile_keys.push_back(key);
     }
   }
 
-  if (!new_tile_keys.empty()) {
-    const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
+  if (recreate_invalidated_tiles && !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.
-      // TODO(danakj): Because we have two frames of invalidation during sync
-      // this isn't always true. When sync is gone we can do this again.
-      // PictureLayerTiling* twin_tiling = NULL;
+      const 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),
@@ skipping 750 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