Clean up tile deletion

cc/tiles/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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 72 matching lines @@
 Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) {
   const int i = info.tiling_i_index;
   const int j = info.tiling_j_index;
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   if (!raster_source_->CoversRect(info.enclosing_layer_rect))
     return nullptr;
 
   all_tiles_done_ = false;
-  ScopedTilePtr tile = client_->CreateTile(info);
+  std::unique_ptr<Tile> tile = client_->CreateTile(info);
   Tile* raw_ptr = tile.get();
   tiles_[key] = std::move(tile);
   return raw_ptr;
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* active_twin =
       tree_ == PENDING_TREE ? client_->GetPendingOrActiveTwinTiling(this)
                             : nullptr;
   const Region* invalidation =
@@ skipping 195 matching lines @@
       remove_tiles[TileMapKey(iter.index())].Union(invalid_content_rect);
     }
   }
 
   for (const auto& pair : remove_tiles) {
     const TileMapKey& key = pair.first;
     const gfx::Rect& invalid_content_rect = pair.second;
     // TODO(danakj): This old_tile will not exist if we are committing to a
     // pending tree since there is no tile there to remove, which prevents
     // tiles from knowing the invalidation rect and content id. crbug.com/490847
-    ScopedTilePtr old_tile = TakeTileAt(key.index_x, key.index_y);
+    std::unique_ptr<Tile> old_tile = TakeTileAt(key.index_x, key.index_y);
     if (recreate_tiles && old_tile) {
       Tile::CreateInfo info = CreateInfoForTile(key.index_x, key.index_y);
       if (Tile* tile = CreateTile(info))
         tile->SetInvalidated(invalid_content_rect, old_tile->id());
     }
   }
 }
 
 Tile::CreateInfo PictureLayerTiling::CreateInfoForTile(int i, int j) const {
   gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);
@@ skipping 238 matching lines @@
   texture_rect.Scale(coverage_to_content_scale_.width(),
                      coverage_to_content_scale_.height());
   texture_rect.Intersect(gfx::RectF(gfx::SizeF(tiling_->tiling_size())));
   if (texture_rect.IsEmpty())
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
-ScopedTilePtr PictureLayerTiling::TakeTileAt(int i, int j) {
+std::unique_ptr<Tile> PictureLayerTiling::TakeTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return nullptr;
-  ScopedTilePtr result = std::move(found->second);
+  std::unique_ptr<Tile> result = std::move(found->second);
   tiles_.erase(found);
   return result;
 }
 
 bool PictureLayerTiling::RemoveTileAt(int i, int j) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   tiles_.erase(found);
   return true;
@@ skipping 379 matching lines @@
 size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
   size_t amount = 0;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 }  // namespace cc