cc: Do not cleanup tiles with raster tasks.

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 39 matching lines @@
     if (a_is_occluded != b_is_occluded)
       return a_is_occluded;
 
     // Or if a is farther away from visible.
     return a_priority.distance_to_visible > b_priority.distance_to_visible;
   }
 
  private:
   TreePriority tree_priority_;
 };
+
+// Reset priority as tile is ref-counted and might still be used
+// even though we no longer hold a reference to it here anymore.

[reveman, 2014/07/28 15:50:53]

Please move this comment just above "tile->SetPriority(..." below

[sohanjg, 2014/07/30 11:12:57]

Done.

+void ResetPriority(Tile* tile, WhichTree tree) {

[reveman, 2014/07/28 15:50:53]

I would prefer if you named this "ReleaseTile" and resetting priority is a
implementation detail of it.

[sohanjg, 2014/07/30 11:12:57]

Done.

+  DCHECK(tile);

[reveman, 2014/07/28 15:50:53]

Remove this. It's awkward to not be able to assume that |tile| != NULL in a
function that takes a Tile as its main parameter. If you need to DCHECK |tile|,
do it before calling this function instead. Not sure it's needed though.

[sohanjg, 2014/07/30 11:12:57]

Acknowledged.

+  tile->SetPriority(tree, TilePriority());
+}
+
 }  // namespace
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale,
     const gfx::Size& layer_bounds,
     PictureLayerTilingClient* client) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale,
                                                 layer_bounds,
                                                 client));
 }
@@ skipping 17 matching lines @@
       gfx::ScaleSize(layer_bounds, contents_scale)).IsEmpty()) <<
       "Tiling created with scale too small as contents become empty." <<
       " Layer bounds: " << layer_bounds.ToString() <<
       " Contents scale: " << contents_scale;
 
   tiling_data_.SetTilingSize(content_bounds);
   tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    ResetPriority(it->second.get(), client_->GetTree());
 }
 
 void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
 }
 
 Tile* PictureLayerTiling::CreateTile(int i,
                                      int j,
                                      const PictureLayerTiling* twin_tiling) {
   TileMapKey key(i, j);
@@ skipping 100 matching lines @@
       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;
+
+      ResetPriority(find->second.get(), client_->GetTree());
+
       tiles_.erase(find);
       new_tile_keys.push_back(key);
     }
   }
 
   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.
       const PictureLayerTiling* twin_tiling = NULL;
@@ skipping 364 matching lines @@
   // Iterate to delete all tiles outside of our new live_tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     TileMap::iterator found = tiles_.find(key);
     // If the tile was outside of the recorded region, it won't exist even
     // though it was in the live rect.
-    if (found != tiles_.end())
+    if (found != tiles_.end()) {
+      ResetPriority(found->second.get(), client_->GetTree());
       tiles_.erase(found);
+    }
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(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) {
@@ skipping 374 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