Clean up tile deletion

cc/tiles/picture_layer_tiling.h

 // 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.
 
 #ifndef CC_TILES_PICTURE_LAYER_TILING_H_
 #define CC_TILES_PICTURE_LAYER_TILING_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 21 matching lines @@
 namespace cc {
 
 class RasterSource;
 class PictureLayerTiling;
 class PrioritizedTile;
 
 class CC_EXPORT PictureLayerTilingClient {
  public:
   // Create a tile at the given content_rect (in the contents scale of the
   // tiling) This might return null if the client cannot create such a tile.
-  virtual ScopedTilePtr CreateTile(const Tile::CreateInfo& info) = 0;
+  virtual std::unique_ptr<Tile> CreateTile(const Tile::CreateInfo& info) = 0;
   virtual gfx::Size CalculateTileSize(
     const gfx::Size& content_bounds) const = 0;
   // This invalidation region defines the area (if any, it can by null) that
   // tiles can not be shared between pending and active trees.
   virtual const Region* GetPendingInvalidation() = 0;
   virtual const PictureLayerTiling* GetPendingOrActiveTwinTiling(
       const PictureLayerTiling* tiling) const = 0;
   virtual bool HasValidTilePriorities() const = 0;
   virtual bool RequiresHighResToDraw() const = 0;
 
@@ skipping 208 matching lines @@
   // here. Note that when processing a pending tree, this rect is the same as
   // the visible rect so no tiles are processed in this case.
   enum PriorityRectType {
     VISIBLE_RECT,
     PENDING_VISIBLE_RECT,
     SKEWPORT_RECT,
     SOON_BORDER_RECT,
     EVENTUALLY_RECT
   };
 
-  using TileMap = std::unordered_map<TileMapKey, ScopedTilePtr, TileMapKeyHash>;
+  using TileMap =
+      std::unordered_map<TileMapKey, std::unique_ptr<Tile>, TileMapKeyHash>;
 
   void SetLiveTilesRect(const gfx::Rect& live_tiles_rect);
   void VerifyLiveTilesRect(bool is_on_recycle_tree) const;
   Tile* CreateTile(const Tile::CreateInfo& info);
-  ScopedTilePtr TakeTileAt(int i, int j);
+  std::unique_ptr<Tile> TakeTileAt(int i, int j);
   // Returns true if the Tile existed and was removed from the tiling.
   bool RemoveTileAt(int i, int j);
   bool TilingMatchesTileIndices(const PictureLayerTiling* twin) const;
 
   // Save the required data for computing tile priorities later.
   void SetTilePriorityRects(const gfx::SizeF& content_to_screen_scale,
                             const gfx::Rect& visible_rect_in_content_space,
                             const gfx::Rect& skewport,
                             const gfx::Rect& soon_border_rect,
                             const gfx::Rect& eventually_rect,
@@ skipping 73 matching lines @@
   bool has_eventually_rect_tiles_ = false;
   bool all_tiles_done_ = true;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PictureLayerTiling);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_PICTURE_LAYER_TILING_H_