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 76 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) {
+    Tile* tile = it->second.get();
+    tile->SetPriority(ACTIVE_TREE, TilePriority());
+    tile->SetPriority(PENDING_TREE, TilePriority());

[reveman, 2014/07/24 13:36:24]

I don't think you can reset both pending and active priority here. What about
the twin tiling that might be alive and using one of these?

[sohanjg, 2014/07/24 15:01:55]

If we reset the priority of only the pending tree here,
how do we reset for the active tree before we drop the tile ?
Vlad , enne ?

[vmpstr, 2014/07/24 16:19:21]

Since at this point the tile can be shared on both trees, you should only reset
the priority of the tree that it's on. You might have to add WhichTree
PictureLayerTilingClient::GetTree(); and then do 

tile->SetPriority(client_->GetTree(), TilePriority());

If the tile is released into tile manager that means one of two things: 1. It
wasn't shared, in which case the other priority wasn't ever set or 2. both trees
released it, which means you would get two of these tilings releasing the same
tile with a different client_->GetTree value.

(I mean this is the reason that I was OK with clearing it in tile manager: it's
just a final stop for the tile... here works as well, but it's a bit more work).

[sohanjg, 2014/07/25 09:38:26]

Done.

+  }
 }
 
 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;
+
+      // Reset priority as tile is ref-counted and might still be used
+      // even though we no longer hold a reference to it here anymore.
+      Tile* tile = find->second.get();
+      tile->SetPriority(ACTIVE_TREE, TilePriority());
+      tile->SetPriority(PENDING_TREE, TilePriority());

[reveman, 2014/07/24 13:36:24]

same here. resetting both active and pending priority seems wrong.

[sohanjg, 2014/07/25 09:38:26]

Done.

+
       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()) {
+      Tile* tile = found->second.get();
+      tile->SetPriority(ACTIVE_TREE, TilePriority());
+      tile->SetPriority(PENDING_TREE, TilePriority());

[reveman, 2014/07/24 13:36:24]

and here. resetting both active and pending priority seems wrong.

[sohanjg, 2014/07/25 09:38:26]

Done.

       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