cc: Do not cleanup tiles with raster tasks.

During cleanup, this keeps the tiles around until the 
associated raster tasks completes running on the worker thread.
We reset the priority of the tile on the tree it lies before
dropping it.

BUG=386039

Review URL: https://codereview.chromium.org/366113002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287304 0039d316-1c4b-4281-b951-d872f2087c98

18 files changed, 201 insertions, 22 deletions

diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index ff36c15..0e5a646 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -123,6 +123,7 @@ class CC_EXPORT PictureLayerImpl
   virtual size_t GetMaxTilesForInterestArea() const OVERRIDE;
   virtual float GetSkewportTargetTimeInSeconds() const OVERRIDE;
   virtual int GetSkewportExtrapolationLimitInContentPixels() const OVERRIDE;
+  virtual WhichTree GetTree() const OVERRIDE;
 
   // PushPropertiesTo active tree => pending tree.
   void SyncTiling(const PictureLayerTiling* tiling);
@@ -137,7 +138,6 @@ class CC_EXPORT PictureLayerImpl
 
   // Functions used by tile manager.
   PictureLayerImpl* GetTwinLayer() { return twin_layer_; }
-  WhichTree GetTree() const;
   bool IsOnActiveOrPendingTree() const;
   bool HasValidTilePriorities() const;
   bool AllTilesRequiredForActivationAreReadyToDraw() const;
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 2809d70..79af4e9 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -58,6 +58,13 @@ class TileEvictionOrder {
  private:
   TreePriority tree_priority_;
 };
+
+void ReleaseTile(Tile* tile, WhichTree tree) {
+  // 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->SetPriority(tree, TilePriority());
+}
+
 }  // namespace
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
@@ -99,6 +106,8 @@ PictureLayerTiling::PictureLayerTiling(float contents_scale,
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it)
+    ReleaseTile(it->second.get(), client_->GetTree());
 }
 
 void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
@@ -219,6 +228,9 @@ void PictureLayerTiling::DoInvalidate(const Region& layer_region,
       TileMap::iterator find = tiles_.find(key);
       if (find == tiles_.end())
         continue;
+
+      ReleaseTile(find->second.get(), client_->GetTree());
+
       tiles_.erase(find);
       new_tile_keys.push_back(key);
     }
@@ -614,8 +626,10 @@ void PictureLayerTiling::SetLiveTilesRect(
     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()) {
+      ReleaseTile(found->second.get(), client_->GetTree());
       tiles_.erase(found);
+    }
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index 285f64d..5aaadf1 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -47,6 +47,7 @@ class CC_EXPORT PictureLayerTilingClient {
   virtual size_t GetMaxTilesForInterestArea() const = 0;
   virtual float GetSkewportTargetTimeInSeconds() const = 0;
   virtual int GetSkewportExtrapolationLimitInContentPixels() const = 0;
+  virtual WhichTree GetTree() const = 0;
 
  protected:
   virtual ~PictureLayerTilingClient() {}
diff --git a/cc/resources/picture_layer_tiling_perftest.cc b/cc/resources/picture_layer_tiling_perftest.cc
index 575e13e..f0be5bf 100644
--- a/cc/resources/picture_layer_tiling_perftest.cc
+++ b/cc/resources/picture_layer_tiling_perftest.cc
@@ -45,6 +45,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
   virtual void SetUp() OVERRIDE {
     picture_layer_tiling_client_.SetTileSize(gfx::Size(256, 256));
     picture_layer_tiling_client_.set_max_tiles_for_interest_area(250);
+    picture_layer_tiling_client_.set_tree(PENDING_TREE);
     picture_layer_tiling_ = PictureLayerTiling::Create(
         1, gfx::Size(256 * 50, 256 * 50), &picture_layer_tiling_client_);
     picture_layer_tiling_->CreateAllTilesForTesting();
@@ -135,6 +136,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
     gfx::Size bounds(viewport.size());
     picture_layer_tiling_ =
         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->UpdateTilePriorities(
         ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
@@ -159,6 +161,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
     gfx::Size bounds(10000, 10000);
     picture_layer_tiling_ =
         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->UpdateTilePriorities(
         ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
@@ -188,6 +191,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
     gfx::Size bounds(viewport.size());
     picture_layer_tiling_ =
         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->UpdateTilePriorities(
         ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
@@ -217,6 +221,7 @@ class PictureLayerTilingPerfTest : public testing::Test {
     gfx::Size bounds(10000, 10000);
     picture_layer_tiling_ =
         PictureLayerTiling::Create(1, bounds, &picture_layer_tiling_client_);
+    picture_layer_tiling_client_.set_tree(ACTIVE_TREE);
     picture_layer_tiling_->UpdateTilePriorities(
         ACTIVE_TREE, viewport, 1.0f, 1.0, NULL, NULL, gfx::Transform());
 
diff --git a/cc/resources/picture_layer_tiling_set_unittest.cc b/cc/resources/picture_layer_tiling_set_unittest.cc
index f4feda7..ca75751 100644
--- a/cc/resources/picture_layer_tiling_set_unittest.cc
+++ b/cc/resources/picture_layer_tiling_set_unittest.cc
@@ -207,6 +207,7 @@ class PictureLayerTilingSetTestWithResources : public testing::Test {
 
     FakePictureLayerTilingClient client(resource_provider.get());
     client.SetTileSize(gfx::Size(256, 256));
+    client.set_tree(PENDING_TREE);
     gfx::Size layer_bounds(1000, 800);
     PictureLayerTilingSet set(&client, layer_bounds);
 
@@ -287,7 +288,9 @@ class PictureLayerTilingSetSyncTest : public testing::Test {
         source_bounds_(gfx::Size(30, 20)),
         target_bounds_(gfx::Size(30, 30)) {
     source_client_.SetTileSize(tile_size_);
+    source_client_.set_tree(PENDING_TREE);
     target_client_.SetTileSize(tile_size_);
+    target_client_.set_tree(PENDING_TREE);
     source_.reset(new PictureLayerTilingSet(&source_client_, source_bounds_));
     target_.reset(new PictureLayerTilingSet(&target_client_, target_bounds_));
   }
diff --git a/cc/resources/picture_layer_tiling_unittest.cc b/cc/resources/picture_layer_tiling_unittest.cc
index 86f60ac..9566489 100644
--- a/cc/resources/picture_layer_tiling_unittest.cc
+++ b/cc/resources/picture_layer_tiling_unittest.cc
@@ -83,6 +83,7 @@ class PictureLayerTilingIteratorTest : public testing::Test {
                   float contents_scale,
                   const gfx::Size& layer_bounds) {
     client_.SetTileSize(tile_size);
+    client_.set_tree(PENDING_TREE);
     tiling_ = TestablePictureLayerTiling::Create(contents_scale,
                                                  layer_bounds,
                                                  &client_);
@@ -338,6 +339,7 @@ TEST_F(PictureLayerTilingIteratorTest, NonContainedDestRect) {
 TEST(PictureLayerTilingTest, SkewportLimits) {
   FakePictureLayerTilingClient client;
   client.set_skewport_extrapolation_limit_in_content_pixels(75);
+  client.set_tree(ACTIVE_TREE);
   scoped_ptr<TestablePictureLayerTiling> tiling;
 
   gfx::Rect viewport(0, 0, 100, 100);
@@ -410,6 +412,7 @@ TEST(PictureLayerTilingTest, ComputeSkewport) {
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
 
   tiling->UpdateTilePriorities(
@@ -469,6 +472,7 @@ TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
   gfx::Size layer_bounds(1500, 1500);
 
   client.SetTileSize(gfx::Size(10, 10));
+  client.set_tree(ACTIVE_TREE);
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
@@ -856,6 +860,7 @@ TEST(PictureLayerTilingTest, TilingRasterTileIteratorStaticViewport) {
   soon_rect.Inset(-312.f, -312.f, -312.f, -312.f);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
@@ -964,6 +969,7 @@ TEST(PictureLayerTilingTest, TilingRasterTileIteratorMovingViewport) {
   gfx::Size layer_bounds(1000, 1000);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
@@ -1039,6 +1045,7 @@ TEST(PictureLayerTilingTest, TilingEvictionTileIteratorStaticViewport) {
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(30, 30));
+  client.set_tree(ACTIVE_TREE);
 
   tiling = TestablePictureLayerTiling::Create(1.0f, layer_bounds, &client);
   tiling->UpdateTilePriorities(
@@ -1092,6 +1099,7 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExist) {
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
       gfx::Rect(layer_bounds),  // visible content rect
@@ -1121,6 +1129,7 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistGiantViewport) {
 
   gfx::Rect giant_rect(-10000000, -10000000, 1000000000, 1000000000);
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
       gfx::Rect(layer_bounds),  // visible content rect
@@ -1153,6 +1162,7 @@ TEST_F(PictureLayerTilingIteratorTest, TilesExistOutsideViewport) {
   gfx::Rect viewport_rect(1100, 0, 1000, 1000);
   EXPECT_FALSE(viewport_rect.Intersects(gfx::Rect(layer_bounds)));
 
+  client_.set_tree(ACTIVE_TREE);
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 viewport_rect,      // visible content rect
                                 1.f,                // current contents scale
@@ -1183,6 +1193,7 @@ TEST_F(PictureLayerTilingIteratorTest,
 
   gfx::Rect visible_rect(8000, 8000, 50, 50);
 
+  client_.set_tree(ACTIVE_TREE);
   set_max_tiles_for_interest_area(1);
   tiling_->UpdateTilePriorities(ACTIVE_TREE,
                                 visible_rect,       // visible content rect
@@ -1210,6 +1221,7 @@ TEST_F(PictureLayerTilingIteratorTest,
   VerifyTilesExactlyCoverRect(1.f, gfx::Rect(layer_bounds));
   VerifyTiles(1.f, gfx::Rect(layer_bounds), base::Bind(&TileExists, false));
 
+  client_.set_tree(ACTIVE_TREE);
   set_max_tiles_for_interest_area(1);
   tiling_->UpdateTilePriorities(
       ACTIVE_TREE,
@@ -1235,6 +1247,7 @@ TEST_F(PictureLayerTilingIteratorTest, AddTilingsToMatchScale) {
   gfx::Size tile_size(100, 100);
 
   client_.SetTileSize(tile_size);
+  client_.set_tree(PENDING_TREE);
 
   PictureLayerTilingSet active_set(&client_, layer_bounds);
 
@@ -1300,6 +1313,7 @@ TEST(UpdateTilePrioritiesTest, VisibleTiles) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1356,6 +1370,7 @@ TEST(UpdateTilePrioritiesTest, OffscreenTiles) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1422,6 +1437,7 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenLayer) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1482,6 +1498,7 @@ TEST(UpdateTilePrioritiesTest, PartiallyOffscreenRotatedLayer) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1566,6 +1583,7 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayer) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1660,6 +1678,7 @@ TEST(UpdateTilePrioritiesTest, PerspectiveLayerClippedByW) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1724,6 +1743,7 @@ TEST(UpdateTilePrioritiesTest, BasicMotion) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
@@ -1805,6 +1825,7 @@ TEST(UpdateTilePrioritiesTest, RotationMotion) {
       current_screen_transform, device_viewport);
 
   client.SetTileSize(gfx::Size(100, 100));
+  client.set_tree(ACTIVE_TREE);
   tiling = TestablePictureLayerTiling::Create(1.0f,  // contents_scale
                                               current_layer_bounds,
                                               &client);
diff --git a/cc/resources/prioritized_tile_set.cc b/cc/resources/prioritized_tile_set.cc
index b7b3b5a..82c7f16 100644
--- a/cc/resources/prioritized_tile_set.cc
+++ b/cc/resources/prioritized_tile_set.cc
@@ -81,6 +81,14 @@ void PrioritizedTileSet::Clear() {
   }
 }
 
+bool PrioritizedTileSet::IsEmpty() {
+  for (int bin = 0; bin < NUM_BINS; ++bin)
+    if (!tiles_[bin].empty())
+      return false;
+
+  return true;
+}
+
 void PrioritizedTileSet::SortBinIfNeeded(ManagedTileBin bin) {
   if (!bin_sorted_[bin]) {
     SortBinTiles(bin, &tiles_[bin]);
diff --git a/cc/resources/prioritized_tile_set.h b/cc/resources/prioritized_tile_set.h
index 15d0e4f..2d4693e 100644
--- a/cc/resources/prioritized_tile_set.h
+++ b/cc/resources/prioritized_tile_set.h
@@ -20,6 +20,7 @@ class CC_EXPORT PrioritizedTileSet {
 
   void InsertTile(Tile* tile, ManagedTileBin bin);
   void Clear();
+  bool IsEmpty();
 
   class CC_EXPORT Iterator {
    public:
diff --git a/cc/resources/prioritized_tile_set_unittest.cc b/cc/resources/prioritized_tile_set_unittest.cc
index f0a01d2..db00645 100644
--- a/cc/resources/prioritized_tile_set_unittest.cc
+++ b/cc/resources/prioritized_tile_set_unittest.cc
@@ -77,6 +77,15 @@ class PrioritizedTileSetTest : public testing::Test {
                                      0,
                                      0);
   }
+  void ReleaseTiles(std::vector<scoped_refptr<Tile> >* tiles) {
+    for (std::vector<scoped_refptr<Tile> >::iterator it = tiles->begin();
+         it != tiles->end();
+         it++) {
+      Tile* tile = *it;
+      tile->SetPriority(ACTIVE_TREE, TilePriority());
+      tile->SetPriority(PENDING_TREE, TilePriority());
+    }
+  }
 
  private:
   LayerTreeSettings settings_;
@@ -142,6 +151,8 @@ TEST_F(PrioritizedTileSetTest, NowAndReadyToDrawBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, NowBin) {
@@ -176,6 +187,8 @@ TEST_F(PrioritizedTileSetTest, NowBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, SoonBin) {
@@ -210,6 +223,8 @@ TEST_F(PrioritizedTileSetTest, SoonBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, SoonBinNoPriority) {
@@ -242,6 +257,8 @@ TEST_F(PrioritizedTileSetTest, SoonBinNoPriority) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, EventuallyAndActiveBin) {
@@ -276,6 +293,8 @@ TEST_F(PrioritizedTileSetTest, EventuallyAndActiveBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, EventuallyBin) {
@@ -310,6 +329,8 @@ TEST_F(PrioritizedTileSetTest, EventuallyBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, AtLastAndActiveBin) {
@@ -344,6 +365,8 @@ TEST_F(PrioritizedTileSetTest, AtLastAndActiveBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, AtLastBin) {
@@ -378,6 +401,8 @@ TEST_F(PrioritizedTileSetTest, AtLastBin) {
     ++i;
   }
   EXPECT_EQ(20, i);
+
+  ReleaseTiles(&tiles);
 }
 
 TEST_F(PrioritizedTileSetTest, TilesForEachBin) {
@@ -528,6 +553,14 @@ TEST_F(PrioritizedTileSetTest, ManyTilesForEachBin) {
   }
 
   EXPECT_FALSE(it);
+
+  ReleaseTiles(&now_and_ready_to_draw_bins);
+  ReleaseTiles(&now_bins);
+  ReleaseTiles(&soon_bins);
+  ReleaseTiles(&eventually_and_active_bins);
+  ReleaseTiles(&eventually_bins);
+  ReleaseTiles(&at_last_bins);
+  ReleaseTiles(&at_last_and_active_bins);
 }
 
 TEST_F(PrioritizedTileSetTest, ManyTilesForEachBinDisablePriority) {
@@ -637,6 +670,14 @@ TEST_F(PrioritizedTileSetTest, ManyTilesForEachBinDisablePriority) {
   }
 
   EXPECT_FALSE(it);
+
+  ReleaseTiles(&now_and_ready_to_draw_bins);
+  ReleaseTiles(&now_bins);
+  ReleaseTiles(&soon_bins);
+  ReleaseTiles(&eventually_and_active_bins);
+  ReleaseTiles(&eventually_bins);
+  ReleaseTiles(&at_last_bins);
+  ReleaseTiles(&at_last_and_active_bins);
 }
 
 TEST_F(PrioritizedTileSetTest, TilesForFirstAndLastBins) {
diff --git a/cc/resources/tile.cc b/cc/resources/tile.cc
index 2725a93..e2aa503 100644
--- a/cc/resources/tile.cc
+++ b/cc/resources/tile.cc
@@ -113,4 +113,12 @@ RasterMode Tile::DetermineRasterModeForResolution(
   return std::min(raster_mode, current_mode);
 }
 
+bool Tile::HasRasterTask() const {
+  for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
+    if (managed_state_.tile_versions[mode].raster_task_)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace cc
diff --git a/cc/resources/tile.h b/cc/resources/tile.h
index 8d91446..01a733c 100644
--- a/cc/resources/tile.h
+++ b/cc/resources/tile.h
@@ -174,6 +174,8 @@ class CC_EXPORT Tile : public RefCountedManaged<Tile> {
   const ManagedTileState& managed_state() const { return managed_state_; }
   RasterMode DetermineRasterModeForResolution(TileResolution resolution) const;
 
+  bool HasRasterTask() const;
+
   TileManager* tile_manager_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect tile_size_;
diff --git a/cc/resources/tile_manager.cc b/cc/resources/tile_manager.cc
index f6405bf..452d9b4 100644
--- a/cc/resources/tile_manager.cc
+++ b/cc/resources/tile_manager.cc
@@ -391,9 +391,6 @@ TileManager::~TileManager() {
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
-  CleanUpReleasedTiles();
-  DCHECK_EQ(0u, tiles_.size());
-
   RasterTaskQueue empty;
   rasterizer_->ScheduleTasks(&empty);
   orphan_raster_tasks_.clear();
@@ -403,11 +400,18 @@ TileManager::~TileManager() {
   rasterizer_->Shutdown();
   rasterizer_->CheckForCompletedTasks();
 
+  prioritized_tiles_.Clear();
+
+  FreeResourcesForReleasedTiles();
+  CleanUpReleasedTiles();
+
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 }
 
 void TileManager::Release(Tile* tile) {
+  DCHECK(TilePriority() == tile->combined_priority());
+
   prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
@@ -420,18 +424,30 @@ bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
-void TileManager::CleanUpReleasedTiles() {
+void TileManager::FreeResourcesForReleasedTiles() {
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
        it != released_tiles_.end();
        ++it) {
     Tile* tile = *it;
-    ManagedTileState& mts = tile->managed_state();
+    FreeResourcesForTile(tile);
+  }
+}
 
-    for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
-      FreeResourceForTile(tile, static_cast<RasterMode>(mode));
-      orphan_raster_tasks_.push_back(mts.tile_versions[mode].raster_task_);
+void TileManager::CleanUpReleasedTiles() {
+  // Make sure |prioritized_tiles_| doesn't contain any of the tiles
+  // we're about to delete.
+  DCHECK(prioritized_tiles_.IsEmpty());
+
+  std::vector<Tile*>::iterator it = released_tiles_.begin();
+  while (it != released_tiles_.end()) {
+    Tile* tile = *it;
+
+    if (tile->HasRasterTask()) {
+      ++it;
+      continue;
     }
 
+    DCHECK(!tile->HasResources());
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
@@ -444,18 +460,19 @@ void TileManager::CleanUpReleasedTiles() {
     }
 
     delete tile;
+    it = released_tiles_.erase(it);
   }
-
-  released_tiles_.clear();
 }
 
 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
   if (!prioritized_tiles_dirty_)
     return;
 
+  prioritized_tiles_.Clear();
+
+  FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
-  prioritized_tiles_.Clear();
   GetTilesWithAssignedBins(&prioritized_tiles_);
   prioritized_tiles_dirty_ = false;
 }
@@ -486,6 +503,8 @@ void TileManager::DidFinishRunningTasks() {
     return;
   }
 
+  FreeResourcesForReleasedTiles();
+
   resource_pool_->ReduceResourceUsage();
 
   // We don't reserve memory for required-for-activation tiles during
@@ -1080,14 +1099,9 @@ void TileManager::OnRasterTaskCompleted(
     RasterMode raster_mode,
     const PicturePileImpl::Analysis& analysis,
     bool was_canceled) {
-  TileMap::iterator it = tiles_.find(tile_id);
-  if (it == tiles_.end()) {
-    ++update_visible_tiles_stats_.canceled_count;
-    resource_pool_->ReleaseResource(resource.Pass());
-    return;
-  }
+  DCHECK(tiles_.find(tile_id) != tiles_.end());
 
-  Tile* tile = it->second;
+  Tile* tile = tiles_[tile_id];
   ManagedTileState& mts = tile->managed_state();
   ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode];
   DCHECK(tile_version.raster_task_);
diff --git a/cc/resources/tile_manager.h b/cc/resources/tile_manager.h
index d4c549c..fa5c650 100644
--- a/cc/resources/tile_manager.h
+++ b/cc/resources/tile_manager.h
@@ -151,7 +151,11 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   void SetRasterizerForTesting(Rasterizer* rasterizer);
 
-  void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); }
+  void FreeResourcesAndCleanUpReleasedTilesForTesting() {
+    prioritized_tiles_.Clear();
+    FreeResourcesForReleasedTiles();
+    CleanUpReleasedTiles();
+  }
 
  protected:
   TileManager(TileManagerClient* client,
@@ -164,6 +168,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
   friend class Tile;
   void DidChangeTilePriority(Tile* tile);
 
+  void FreeResourcesForReleasedTiles();
   void CleanUpReleasedTiles();
 
   // Overriden from RefCountedManager<Tile>:
diff --git a/cc/resources/tile_manager_perftest.cc b/cc/resources/tile_manager_perftest.cc
index d703f71..211ff01 100644
--- a/cc/resources/tile_manager_perftest.cc
+++ b/cc/resources/tile_manager_perftest.cc
@@ -332,7 +332,7 @@ class TileManagerPerfTest : public testing::Test {
 
     // Ensure that we start with blank trees and no tiles.
     host_impl_.ResetTreesForTesting();
-    tile_manager()->CleanUpReleasedTilesForTesting();
+    tile_manager()->FreeResourcesAndCleanUpReleasedTilesForTesting();
 
     gfx::Size layer_bounds(width, height);
     gfx::Size viewport(width / 5, height / 5);
diff --git a/cc/resources/tile_manager_unittest.cc b/cc/resources/tile_manager_unittest.cc
index 87aa880..98e63fe 100644
--- a/cc/resources/tile_manager_unittest.cc
+++ b/cc/resources/tile_manager_unittest.cc
@@ -124,6 +124,14 @@ class TileManagerTest : public testing::TestWithParam<bool>,
         count, active_priority, pending_priority, settings_.default_tile_size);
   }
 
+  void ReleaseTiles(TileVector* tiles) {
+    for (TileVector::iterator it = tiles->begin(); it != tiles->end(); it++) {
+      Tile* tile = *it;
+      tile->SetPriority(ACTIVE_TREE, TilePriority());
+      tile->SetPriority(PENDING_TREE, TilePriority());
+    }
+  }
+
   FakeTileManager* tile_manager() { return tile_manager_.get(); }
 
   int AssignedMemoryCount(const TileVector& tiles) {
@@ -179,6 +187,11 @@ TEST_P(TileManagerTest, EnoughMemoryAllowAnything) {
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTiles(&active_now);
+  ReleaseTiles(&pending_now);
+  ReleaseTiles(&active_pending_soon);
+  ReleaseTiles(&never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
@@ -200,6 +213,11 @@ TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) {
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTiles(&active_now);
+  ReleaseTiles(&pending_now);
+  ReleaseTiles(&active_pending_soon);
+  ReleaseTiles(&never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
@@ -213,6 +231,7 @@ TEST_P(TileManagerTest, EnoughMemoryPendingLowResAllowAbsoluteMinimum) {
   tile_manager()->AssignMemoryToTiles(global_state_);
 
   EXPECT_EQ(5, AssignedMemoryCount(pending_low_res));
+  ReleaseTiles(&pending_low_res);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
@@ -234,6 +253,11 @@ TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) {
   EXPECT_EQ(3, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTiles(&active_now);
+  ReleaseTiles(&pending_now);
+  ReleaseTiles(&active_pending_soon);
+  ReleaseTiles(&never_bin);
 }
 
 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
@@ -255,6 +279,11 @@ TEST_P(TileManagerTest, EnoughMemoryAllowNothing) {
   EXPECT_EQ(0, AssignedMemoryCount(pending_now));
   EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon));
   EXPECT_EQ(0, AssignedMemoryCount(never_bin));
+
+  ReleaseTiles(&active_now);
+  ReleaseTiles(&pending_now);
+  ReleaseTiles(&active_pending_soon);
+  ReleaseTiles(&never_bin);
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
@@ -279,6 +308,9 @@ TEST_P(TileManagerTest, PartialOOMMemoryToPending) {
 
   EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
@@ -298,6 +330,9 @@ TEST_P(TileManagerTest, PartialOOMMemoryToActive) {
 
   EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
@@ -329,6 +364,9 @@ TEST_P(TileManagerTest, TotalOOMMemoryToPending) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
@@ -360,6 +398,9 @@ TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) {
     EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(8, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
@@ -384,6 +425,9 @@ TEST_P(TileManagerTest, TotalOOMMemoryToActive) {
     EXPECT_EQ(8, AssignedMemoryCount(active_tree_tiles));
     EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles));
   }
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
@@ -423,6 +467,9 @@ TEST_P(TileManagerTest, TotalOOMMemoryToNewContent) {
   tile_manager()->AssignMemoryToTiles(global_state_);
   EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles));
   EXPECT_EQ(10, AssignedMemoryCount(pending_tree_tiles));
+
+  ReleaseTiles(&active_tree_tiles);
+  ReleaseTiles(&pending_tree_tiles);
 }
 
 // If true, the max tile limit should be applied as bytes; if false,
diff --git a/cc/test/fake_picture_layer_tiling_client.cc b/cc/test/fake_picture_layer_tiling_client.cc
index 7834bc0..2bd756d 100644
--- a/cc/test/fake_picture_layer_tiling_client.cc
+++ b/cc/test/fake_picture_layer_tiling_client.cc
@@ -79,4 +79,8 @@ const PictureLayerTiling* FakePictureLayerTilingClient::GetTwinTiling(
   return twin_tiling_;
 }
 
+WhichTree FakePictureLayerTilingClient::GetTree() const {
+  return tree_;
+}
+
 }  // namespace cc
diff --git a/cc/test/fake_picture_layer_tiling_client.h b/cc/test/fake_picture_layer_tiling_client.h
index 6bdede0..f46cc84 100644
--- a/cc/test/fake_picture_layer_tiling_client.h
+++ b/cc/test/fake_picture_layer_tiling_client.h
@@ -36,6 +36,7 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
   virtual const Region* GetInvalidation() OVERRIDE;
   virtual const PictureLayerTiling* GetTwinTiling(
       const PictureLayerTiling* tiling) const OVERRIDE;
+  virtual WhichTree GetTree() const OVERRIDE;
 
   void set_twin_tiling(PictureLayerTiling* tiling) { twin_tiling_ = tiling; }
   void set_text_rect(const gfx::Rect& rect) { text_rect_ = rect; }
@@ -50,6 +51,7 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
   void set_skewport_extrapolation_limit_in_content_pixels(int limit) {
     skewport_extrapolation_limit_in_content_pixels_ = limit;
   }
+  void set_tree(WhichTree tree) { tree_ = tree; }
 
   TileManager* tile_manager() const {
     return tile_manager_.get();
@@ -68,6 +70,7 @@ class FakePictureLayerTilingClient : public PictureLayerTilingClient {
   size_t max_tiles_for_interest_area_;
   float skewport_target_time_in_seconds_;
   int skewport_extrapolation_limit_in_content_pixels_;
+  WhichTree tree_;
 };
 
 }  // namespace cc
diff --git a/cc/test/fake_tile_manager.cc b/cc/test/fake_tile_manager.cc
index 1fc2e43..d15819d 100644
--- a/cc/test/fake_tile_manager.cc
+++ b/cc/test/fake_tile_manager.cc
@@ -100,6 +100,8 @@ void FakeTileManager::DidFinishRunningTasksForTesting() {
 
 void FakeTileManager::Release(Tile* tile) {
   TileManager::Release(tile);
+
+  FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 }