cc: Make the TileManager operate on ManagedTileState directly

cc/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/picture_layer_tiling.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/math_util.h"
 #include "ui/gfx/point_conversions.h"
 #include "ui/gfx/rect_conversions.h"
@@ skipping 32 matching lines @@
 }
 
 gfx::SizeF PictureLayerTiling::ContentSizeF() const {
   return gfx::ScaleSize(layer_bounds_, contents_scale_);
 }
 
 Tile* PictureLayerTiling::TileAt(int i, int j) const {
   TileMap::const_iterator iter = tiles_.find(TileMapKey(i, j));
   if (iter == tiles_.end())
     return NULL;
-  return iter->second.get();
+  return iter->second.tile();
 }
 
 void PictureLayerTiling::CreateTile(int i, int j) {
   gfx::Rect tile_rect = tiling_data_.TileBoundsWithBorder(i, j);
   tile_rect.set_size(tiling_data_.max_texture_size());
   TileMapKey key(i, j);
   DCHECK(tiles_.find(key) == tiles_.end());
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
   if (tile)
-    tiles_[key] = tile;
+    tiles_.insert(make_pair(key, TileHandle(tile)));
 }
 
 Region PictureLayerTiling::OpaqueRegionInContentRect(
     const gfx::Rect& content_rect) const {
   Region opaque_region;
   // TODO(enne): implement me
   return opaque_region;
 }
 
 void PictureLayerTiling::SetLayerBounds(gfx::Size layer_bounds) {
@@ skipping 333 matching lines @@
                                            last_prioritized_rect_,
                                            inflated_rect);
        iter;
        ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
 
     TilePriority priority;
     DCHECK(!priority.is_live);
-    Tile* tile = find->second.get();
+    TileHandle* tile_handle = &find->second;
+    Tile* tile = tile_handle->tile();
     tile->set_priority(tree, priority);
   }
   last_prioritized_rect_ = inflated_rect;
 
   gfx::Rect view_rect(device_viewport);
   float current_scale = current_layer_contents_scale / contents_scale_;
   float last_scale = last_layer_contents_scale / contents_scale_;
 
   // Fast path tile priority calculation when both transforms are translations.
   if (last_screen_transform.IsIdentityOrTranslation() &&
       current_screen_transform.IsIdentityOrTranslation())
   {
     gfx::Vector2dF current_offset(
         current_screen_transform.matrix().get(0, 3),
         current_screen_transform.matrix().get(1, 3));
     gfx::Vector2dF last_offset(
         last_screen_transform.matrix().get(0, 3),
         last_screen_transform.matrix().get(1, 3));
 
     for (TilingData::Iterator iter(&tiling_data_, inflated_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
       if (find == tiles_.end())
         continue;
-      Tile* tile = find->second.get();
+      TileHandle* tile_handle = &find->second;
+      Tile* tile = tile_handle->tile();
 
       gfx::Rect tile_bounds =
           tiling_data_.TileBounds(iter.index_x(), iter.index_y());
       gfx::RectF current_screen_rect = gfx::ScaleRect(
           tile_bounds,
           current_scale,
           current_scale) + current_offset;
       gfx::RectF last_screen_rect = gfx::ScaleRect(
           tile_bounds,
           last_scale,
@@ skipping 12 matching lines @@
       if (store_screen_space_quads_on_tiles)
         priority.set_current_screen_quad(gfx::QuadF(current_screen_rect));
       tile->set_priority(tree, priority);
     }
   } else {
     for (TilingData::Iterator iter(&tiling_data_, inflated_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
       if (find == tiles_.end())
         continue;
-      Tile* tile = find->second.get();
+      TileHandle* tile_handle = &find->second;
+      Tile* tile = tile_handle->tile();
 
       gfx::Rect tile_bounds =
           tiling_data_.TileBounds(iter.index_x(), iter.index_y());
       gfx::RectF current_layer_content_rect = gfx::ScaleRect(
           tile_bounds,
           current_scale,
           current_scale);
       gfx::RectF current_screen_rect = MathUtil::mapClippedRect(
           current_screen_transform, current_layer_content_rect);
       gfx::RectF last_layer_content_rect = gfx::ScaleRect(
@@ skipping 24 matching lines @@
       tile->set_priority(tree, priority);
     }
   }
 
   last_source_frame_number_ = current_source_frame_number;
   last_impl_frame_time_ = current_frame_time;
 }
 
 void PictureLayerTiling::DidBecomeActive() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->set_priority(ACTIVE_TREE, it->second->priority(PENDING_TREE));
-    it->second->set_priority(PENDING_TREE, TilePriority());
+    Tile* tile = it->second.tile();
+    tile->set_priority(ACTIVE_TREE, tile->priority(PENDING_TREE));
+    tile->set_priority(PENDING_TREE, TilePriority());
 
     // Tile holds a ref onto a picture pile. If the tile never gets invalidated
     // and recreated, then that picture pile ref could exist indefinitely.  To
     // prevent this, ask the client to update the pile to its own ref.  This
     // will cause PicturePileImpls and their clones to get deleted once the
     // corresponding PictureLayerImpl and any in flight raster jobs go out of
     // scope.
-    client_->UpdatePile(it->second);
+    client_->UpdatePile(tile);
   }
 }
 
 scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("num_tiles", tiles_.size());
   state->SetDouble("content_scale", contents_scale_);
   state->Set("content_bounds",
              MathUtil::asValue(ContentRect().size()).release());
   return state.PassAs<base::Value>();
 }
 
+TileHandle::TileHandle(scoped_refptr<Tile> tile)
+    : tile_(tile),
+      managed_tile_state_(tile_->tile_manager()->RegisterTile(tile_)) {
+}
+
+TileHandle::~TileHandle() {
+}
+
 }  // namespace cc