Revert "cc: Remove Tile refcounting and RefCountedManaged."

cc/resources/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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 88 matching lines @@
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
 
   gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
   gfx::Rect tile_rect = paint_rect;
   tile_rect.set_size(tiling_data_.max_texture_size());
 
   if (!raster_source_->CoversRect(tile_rect, contents_scale_))
     return nullptr;
 
-  ScopedTilePtr tile = client_->CreateTile(contents_scale_, tile_rect);
-  Tile* raw_ptr = tile.get();
+  scoped_refptr<Tile> tile = client_->CreateTile(contents_scale_, tile_rect);
   tile->set_tiling_index(i, j);
-  tiles_.add(key, tile.Pass());
-  return raw_ptr;
+  tiles_[key] = tile;
+  return tile.get();
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   bool include_borders = false;
   for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_,
                                  include_borders);
        iter; ++iter) {
     TileMapKey key = iter.index();
     TileMap::iterator find = tiles_.find(key);
     if (find != tiles_.end())
@@ skipping 18 matching lines @@
 
   resolution_ = pending_twin->resolution_;
   bool create_missing_tiles = false;
   if (live_tiles_rect_.IsEmpty()) {
     live_tiles_rect_ = pending_twin->live_tiles_rect();
     create_missing_tiles = true;
   } else {
     SetLiveTilesRect(pending_twin->live_tiles_rect());
   }
 
-  if (tiles_.empty()) {
+  if (tiles_.size() < pending_twin->tiles_.size()) {
     tiles_.swap(pending_twin->tiles_);
+    tiles_.insert(pending_twin->tiles_.begin(), pending_twin->tiles_.end());
   } else {
-    while (!pending_twin->tiles_.empty()) {
-      TileMapKey key = pending_twin->tiles_.begin()->first;
-      tiles_.set(key, pending_twin->tiles_.take_and_erase(key));
-      DCHECK(tiles_.get(key)->raster_source() == raster_source_.get());
+    for (TileMap::value_type& tile_pair : pending_twin->tiles_) {
+      tiles_[tile_pair.first].swap(tile_pair.second);
+      DCHECK(tiles_[tile_pair.first]->raster_source() == raster_source_.get());
     }
   }
-  DCHECK(pending_twin->tiles_.empty());
+  pending_twin->tiles_.clear();
 
   if (create_missing_tiles)
     CreateMissingTilesInLiveTilesRect();
 
   VerifyLiveTilesRect(false);
 
   SetTilePriorityRects(pending_twin->current_content_to_screen_scale_,
                        pending_twin->current_visible_rect_,
                        pending_twin->current_skewport_rect_,
                        pending_twin->current_soon_border_rect_,
@@ skipping 500 matching lines @@
       CreateTile(key.first, key.second);
   }
 
   live_tiles_rect_ = new_live_tiles_rect;
   VerifyLiveTilesRect(false);
 }
 
 void PictureLayerTiling::VerifyLiveTilesRect(bool is_on_recycle_tree) const {
 #if DCHECK_IS_ON()
   for (auto it = tiles_.begin(); it != tiles_.end(); ++it) {
-    if (!it->second)
+    if (!it->second.get())
       continue;
     DCHECK(it->first.first < tiling_data_.num_tiles_x())
         << this << " " << it->first.first << "," << it->first.second
         << " num_tiles_x " << tiling_data_.num_tiles_x() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
     DCHECK(it->first.second < tiling_data_.num_tiles_y())
         << this << " " << it->first.first << "," << it->first.second
         << " num_tiles_y " << tiling_data_.num_tiles_y() << " live_tiles_rect "
         << live_tiles_rect_.ToString();
     DCHECK(tiling_data_.TileBounds(it->first.first, it->first.second)
@@ skipping 162 matching lines @@
     return TilePriority(resolution_, TilePriority::SOON, distance_to_visible);
   }
 
   return TilePriority(resolution_, TilePriority::EVENTUALLY,
                       distance_to_visible);
 }
 
 void PictureLayerTiling::GetAllTilesAndPrioritiesForTracing(
     std::map<const Tile*, TilePriority>* tile_map) const {
   for (const auto& tile_pair : tiles_) {
-    const Tile* tile = tile_pair.second;
+    const Tile* tile = tile_pair.second.get();
     const TilePriority& priority = ComputePriorityForTile(tile);
     // Store combined priority.
     (*tile_map)[tile] = priority;
   }
 }
 
 void PictureLayerTiling::AsValueInto(
     base::trace_event::TracedValue* state) const {
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   MathUtil::AddToTracedValue("visible_rect", current_visible_rect_, state);
   MathUtil::AddToTracedValue("skewport_rect", current_skewport_rect_, state);
   MathUtil::AddToTracedValue("soon_rect", current_soon_border_rect_, state);
   MathUtil::AddToTracedValue("eventually_rect", current_eventually_rect_,
                              state);
   MathUtil::AddToTracedValue("tiling_size", tiling_size(), state);
 }
 
 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;
+    const Tile* tile = it->second.get();
     amount += tile->GPUMemoryUsageInBytes();
   }
   return amount;
 }
 
 PictureLayerTiling::RectExpansionCache::RectExpansionCache()
   : previous_target(0) {
 }
 
 namespace {
@@ skipping 137 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc