cc: Don't discard tiles unless memory is low

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"
 #include "ui/gfx/safe_integer_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Create(
     float contents_scale) {
   return make_scoped_ptr(new PictureLayerTiling(contents_scale));
 }
 
 scoped_ptr<PictureLayerTiling> PictureLayerTiling::Clone() const {
-  return make_scoped_ptr(new PictureLayerTiling(*this));
+  PictureLayerTiling* new_tiling = new PictureLayerTiling(*this);
+
+  // The live_tiles_ list was shallow-copied, restore it explicitly.
+  new_tiling->live_tiles_.clear();
+  for (TileList::const_iterator it = live_tiles_.begin();
+       it != live_tiles_.end(); ++it) {
+    const TileHandle* tile_handle = *it;
+    TileMap::iterator find = new_tiling->tiles_.find(tile_handle->key());
+    DCHECK(find != new_tiling->tiles_.end());
+    TileHandle* new_tile_handle = &find->second;
+    new_tile_handle->AddToLiveTileList(new_tiling);
+  }
+
+  return make_scoped_ptr(new_tiling);
 }
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale)
     : client_(NULL),
       contents_scale_(contents_scale),
       tiling_data_(gfx::Size(), gfx::Size(), true),
       resolution_(NON_IDEAL_RESOLUTION),
       last_source_frame_number_(0),
       last_impl_frame_time_(0) {
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
+  tiles_.clear();
+  DCHECK(live_tiles_.empty());
 }
 
 void PictureLayerTiling::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
 }
 
 gfx::Rect PictureLayerTiling::ContentRect() const {
   return gfx::Rect(tiling_data_.total_size());
 }
 
 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.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_.insert(make_pair(key, TileHandle(tile)));
+    tiles_.insert(make_pair(key, TileHandle(key, 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 320 matching lines @@
   gfx::Rect inflated_rect = viewport_in_content_space;
   float adjusted_inset = TilePriority::kMaxDistanceInContentSpace /
                          std::max(contents_scale_, 1.f);
   inflated_rect.Inset(
       -adjusted_inset,
       -adjusted_inset,
       -adjusted_inset,
       -adjusted_inset);
   inflated_rect.Intersect(ContentRect());
 
-  // Iterate through all of the tiles that were live last frame but will
-  // not be live this frame, and mark them as being dead.
-  for (TilingData::DifferenceIterator iter(&tiling_data_,
-                                           last_prioritized_rect_,
-                                           inflated_rect);
-       iter;
-       ++iter) {
+  // Mark all tiles in the inflated rect as live.
+  for (TilingData::Iterator iter(&tiling_data_, inflated_rect);
+       iter; ++iter) {
     TileMap::iterator find = tiles_.find(iter.index());
     if (find == tiles_.end())
       continue;
+    TileHandle* tile_handle = &find->second;
+    tile_handle->set_should_be_live(true);
+    tile_handle->AddToLiveTileList(this);
+  }
 
-    TilePriority priority;
-    DCHECK(!priority.is_live);
-    TileHandle* tile_handle = &find->second;
-    Tile* tile = tile_handle->tile();
-    tile->set_priority(tree, priority);
-    tile_handle->UnregisterFromTileManager();
+  // Iterate through all of the tiles that were live last frame but will
+  // not be live this frame, and mark them as being dead.
+  // TODO(ccameron): merge this loop with the loops below.
+  for (TileList::iterator it = live_tiles_.begin();
+       it != live_tiles_.end(); ) {
+    TileHandle* tile_handle = *it;
+    TileList::iterator it_next = it;
+    it_next++;
+    if (!tile_handle->should_be_live() &&
+        !tile_handle->tile()->GetResourceId()) {
+      TilePriority priority;
+      DCHECK(!priority.is_live);
+      tile_handle->tile()->set_priority(tree, priority);
+      tile_handle->RemoveFromLiveTileList();
+      tile_handle->UnregisterFromTileManager();
+    } else {
+      tile_handle->RegisterWithTileManager();
+      // Mark the tile as not live for the next time through.
+      tile_handle->set_should_be_live(false);
+    }
+    it = it_next;
   }
+
   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;
-      TileHandle* tile_handle = &find->second;
+    for (TileList::iterator it = live_tiles_.begin();
+         it != live_tiles_.end(); ++it) {
+      TileHandle* tile_handle = *it;
       Tile* tile = tile_handle->tile();
-      tile_handle->RegisterWithTileManager();
 
       gfx::Rect tile_bounds =
-          tiling_data_.TileBounds(iter.index_x(), iter.index_y());
+          tiling_data_.TileBounds(tile_handle->key().first,
+                                  tile_handle->key().second);
       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,
           last_scale) + last_offset;
 
       float distance_to_visible_in_pixels =
           TilePriority::manhattanDistance(current_screen_rect, view_rect);
 
       float time_to_visible_in_seconds =
           TilePriority::TimeForBoundsToIntersect(
               last_screen_rect, current_screen_rect, time_delta, view_rect);
       TilePriority priority(
           resolution_,
           time_to_visible_in_seconds,
           distance_to_visible_in_pixels);
       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;
-      TileHandle* tile_handle = &find->second;
+    for (TileList::iterator it = live_tiles_.begin();
+         it != live_tiles_.end(); ++it) {
+      TileHandle* tile_handle = *it;
       Tile* tile = tile_handle->tile();
-      tile_handle->RegisterWithTileManager();
 
       gfx::Rect tile_bounds =
-          tiling_data_.TileBounds(iter.index_x(), iter.index_y());
+          tiling_data_.TileBounds(tile_handle->key().first,
+                                  tile_handle->key().second);
       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(
           tile_bounds,
           last_scale,
           last_scale);
@@ skipping 44 matching lines @@
 
 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) {
+TileHandle::TileHandle(std::pair<int, int> key, scoped_refptr<Tile> tile)
+    : key_(key),
+      tile_(tile),
+      should_be_live_(false),
+      tiling_(NULL) {
+}
+
+TileHandle::TileHandle(const TileHandle& tile_handle)
+    : key_(tile_handle.key_),
+      tile_(tile_handle.tile_),
+      managed_tile_state_(tile_handle.managed_tile_state_),
+      should_be_live_(false),
+      tiling_(NULL) {
+}
+
+TileHandle::~TileHandle() {
+  RemoveFromLiveTileList();
 }
 
 void TileHandle::RegisterWithTileManager() {
   if (managed_tile_state_.get())
     return;
   managed_tile_state_ = tile_->tile_manager()->RegisterTile(tile_);
 }
 
 void TileHandle::UnregisterFromTileManager() {
   managed_tile_state_ = NULL;
 }
 
+void TileHandle::AddToLiveTileList(PictureLayerTiling* tiling) {
+  if (tiling_) {
+    DCHECK(tiling == tiling_);
+    DCHECK(tiling_live_tile_list_iterator_ != tiling_->live_tiles_.end());
+    return;
+  }
+  tiling_ = tiling;
+  tiling_live_tile_list_iterator_ =
+      tiling_->live_tiles_.insert(tiling_->live_tiles_.begin(), this);
+}
+
+void TileHandle::RemoveFromLiveTileList() {
+  if (!tiling_)
+    return;
+  tiling_->live_tiles_.erase(tiling_live_tile_list_iterator_);
+  tiling_live_tile_list_iterator_ = tiling_->live_tiles_.end();
+  tiling_ = NULL;
+}
+
 }  // namespace cc