Revert "cc: Remove Tile refcounting and RefCountedManaged."

cc/resources/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_RESOURCES_TILE_MANAGER_H_
 #define CC_RESOURCES_TILE_MANAGER_H_
 
 #include <deque>
 #include <queue>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "cc/base/ref_counted_managed.h"
 #include "cc/base/unique_notifier.h"
 #include "cc/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/raster_source.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_draw_info.h"
 #include "cc/resources/tile_task_runner.h"
 
@@ skipping 51 matching lines @@
   size_t completed_count;
   size_t canceled_count;
 };
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
 
 // This class manages tiles, deciding which should get rasterized and which
 // should no longer have any memory assigned to them. Tile objects are "owned"
 // by layers; they automatically register with the manager when they are
 // created, and unregister from the manager when they are deleted.
-class CC_EXPORT TileManager : public TileTaskRunnerClient {
+class CC_EXPORT TileManager : public TileTaskRunnerClient,
+                              public RefCountedManager<Tile> {
  public:
   enum NamedTaskSet {
     REQUIRED_FOR_ACTIVATION,
     REQUIRED_FOR_DRAW,
     // PixelBufferTileTaskWorkerPool depends on ALL being last.
     ALL
     // Adding additional values requires increasing kNumberOfTaskSets in
     // tile_task_runner.h
   };
 
@@ skipping 10 matching lines @@
 
   // Assigns tile memory and schedules work to prepare tiles for drawing.
   // - Runs client_->NotifyReadyToActivate() when all tiles required for
   // activation are prepared, or failed to prepare due to OOM.
   // - Runs client_->NotifyReadyToDraw() when all tiles required draw are
   // prepared, or failed to prepare due to OOM.
   void PrepareTiles(const GlobalStateThatImpactsTilePriority& state);
 
   void UpdateVisibleTiles(const GlobalStateThatImpactsTilePriority& state);
 
-  ScopedTilePtr CreateTile(RasterSource* raster_source,
-                           const gfx::Size& desired_texture_size,
-                           const gfx::Rect& content_rect,
-                           float contents_scale,
-                           int layer_id,
-                           int source_frame_number,
-                           int flags);
+  scoped_refptr<Tile> CreateTile(RasterSource* raster_source,
+                                 const gfx::Size& desired_texture_size,
+                                 const gfx::Rect& content_rect,
+                                 float contents_scale,
+                                 int layer_id,
+                                 int source_frame_number,
+                                 int flags);
 
   bool IsReadyToActivate() const;
   bool IsReadyToDraw() const;
 
   scoped_refptr<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 47 matching lines @@
  protected:
   TileManager(TileManagerClient* client,
               const scoped_refptr<base::SequencedTaskRunner>& task_runner,
               ResourcePool* resource_pool,
               TileTaskRunner* tile_task_runner,
               size_t scheduled_raster_task_limit);
 
   void FreeResourcesForReleasedTiles();
   void CleanUpReleasedTiles();
 
+  // Overriden from RefCountedManager<Tile>:
   friend class Tile;
-  // Virtual for testing.
-  virtual void Release(Tile* tile);
+  void Release(Tile* tile) override;
 
   // Overriden from TileTaskRunnerClient:
   void DidFinishRunningTileTasks(TaskSet task_set) override;
   TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
 
   typedef std::vector<Tile*> TileVector;
   typedef std::set<Tile*> TileSet;
 
   // Virtual for test
   virtual void ScheduleTasks(
@@ skipping 99 matching lines @@
 
   bool did_notify_ready_to_activate_;
   bool did_notify_ready_to_draw_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_