Clean up tile deletion

cc/tiles/tile_manager.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_TILE_MANAGER_H_
 #define CC_TILES_TILE_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 112 matching lines @@
                     ImageDecodeCache* image_decode_cache,
                     TaskGraphRunner* task_graph_runner,
                     RasterBufferProvider* raster_buffer_provider,
                     size_t scheduled_raster_task_limit,
                     bool use_gpu_rasterization);
 
   // This causes any completed raster work to finalize, so that tiles get up to
   // date draw information.
   void Flush();
 
-  ScopedTilePtr CreateTile(const Tile::CreateInfo& info,
-                           int layer_id,
-                           int source_frame_number,
-                           int flags);
+  std::unique_ptr<Tile> CreateTile(const Tile::CreateInfo& info,
+                                   int layer_id,
+                                   int source_frame_number,
+                                   int flags);
 
   bool IsReadyToActivate() const;
   bool IsReadyToDraw() const;
 
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   BasicStateAsValue() const;
   void BasicStateAsValueInto(base::trace_event::TracedValue* dict) const;
   const MemoryHistory::Entry& memory_stats_from_last_assign() const {
     return memory_stats_from_last_assign_;
   }
@@ skipping 24 matching lines @@
   void SetTileTaskManagerForTesting(
       std::unique_ptr<TileTaskManager> tile_task_manager) {
     tile_task_manager_ = std::move(tile_task_manager);
   }
 
   void SetRasterBufferProviderForTesting(
       RasterBufferProvider* raster_buffer_provider) {
     raster_buffer_provider_ = raster_buffer_provider;
   }
 
-  void FreeResourcesAndCleanUpReleasedTilesForTesting() {
-    FreeResourcesForReleasedTiles();
-    CleanUpReleasedTiles();
-  }
-
   std::vector<Tile*> AllTilesForTesting() const {
     std::vector<Tile*> tiles;
     for (auto& tile_pair : tiles_)
       tiles.push_back(tile_pair.second);
     return tiles;
   }
 
   void SetScheduledRasterTaskLimitForTesting(size_t limit) {
     scheduled_raster_task_limit_ = limit;
   }
 
   void CheckIfMoreTilesNeedToBePreparedForTesting() {
     CheckIfMoreTilesNeedToBePrepared();
   }
 
   void SetMoreTilesNeedToBeRasterizedForTesting() {
     all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
   }
 
   bool HasScheduledTileTasksForTesting() const {
     return has_scheduled_tile_tasks_;
   }
 
   void OnRasterTaskCompleted(std::unique_ptr<RasterBuffer> raster_buffer,
-                             Tile* tile,
+                             Tile::Id tile_id,
                              Resource* resource,
                              bool was_canceled);
 
  protected:
-  void FreeResourcesForReleasedTiles();
-  void CleanUpReleasedTiles();
-
   friend class Tile;
-  // Virtual for testing.
-  virtual void Release(Tile* tile);
+  // Must be called by tile during destruction.
+  void Release(Tile* tile);
   Tile::Id GetUniqueTileId() { return ++next_tile_id_; }
 
  private:
   class MemoryUsage {
    public:
     MemoryUsage();
     MemoryUsage(size_t memory_bytes, size_t resource_count);
 
     static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
     static MemoryUsage FromTile(const Tile* tile);
@@ skipping 88 matching lines @@
   bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
   bool did_oom_on_last_assign_;
 
   ImageController image_controller_;
 
   RasterTaskCompletionStats flush_stats_;
 
-  std::vector<Tile*> released_tiles_;
-
   TaskGraph graph_;
 
   UniqueNotifier more_tiles_need_prepare_check_notifier_;
 
   Signals signals_;
 
   UniqueNotifier signals_check_notifier_;
 
   bool has_scheduled_tile_tasks_;
 
   uint64_t prepare_tiles_count_;
   uint64_t next_tile_id_;
 
   std::unordered_map<Tile::Id, std::vector<DrawImage>> scheduled_draw_images_;
   std::vector<scoped_refptr<TileTask>> locked_image_tasks_;
   const bool check_tile_priority_inversion_;
 
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_