Makes tile-creation lazy

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 "base/debug/trace_event.h"
 #include "cc/base/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));
+    float contents_scale,
+    gfx::Size layer_bounds,
+    PictureLayerTilingClient* client) {
+  return make_scoped_ptr(new PictureLayerTiling(contents_scale,
+                                                layer_bounds,
+                                                client));
 }
 
-scoped_ptr<PictureLayerTiling> PictureLayerTiling::Clone() const {
-  return make_scoped_ptr(new PictureLayerTiling(*this));
+scoped_ptr<PictureLayerTiling> PictureLayerTiling::Clone(
+    gfx::Size layer_bounds,
+    PictureLayerTilingClient* client) const {
+  scoped_ptr<PictureLayerTiling> out =
+    make_scoped_ptr(new PictureLayerTiling(contents_scale_,
+                                           layer_bounds,
+                                           client));
+  out->resolution_ = resolution_;
+  out->last_source_frame_number_ = last_source_frame_number_;
+  out->last_impl_frame_time_ = last_impl_frame_time_;
+  return out.Pass();
 }
 
-PictureLayerTiling::PictureLayerTiling(float contents_scale)
-    : client_(NULL),
+PictureLayerTiling::PictureLayerTiling(float contents_scale,
+                                       gfx::Size layer_bounds,
+                                       PictureLayerTilingClient* client)
+    : client_(client),
       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) {
+      last_impl_frame_time_(0.0),
+      layer_bounds_(layer_bounds) {
+  gfx::Size content_bounds =
+      gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
+  gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
+
+  tiling_data_.SetTotalSize(content_bounds);
+  tiling_data_.SetMaxTextureSize(tile_size);
 }
 
 PictureLayerTiling::~PictureLayerTiling() {
 }
 
 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.get();
 }
 
 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());
+
+  gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
+  gfx::Rect tile_rect = paint_rect;
+  tile_rect.set_size(tiling_data_.max_texture_size());
+
+  // Check our twin for a valid tile.
+  const PictureLayerTiling* twin = client_->GetTwinTiling(this);
+  if (twin && tiling_data_.max_texture_size() ==
+      twin->tiling_data_.max_texture_size()) {
+    Tile* candidate_tile = twin->TileAt(i, j);
+    if (candidate_tile) {
+      gfx::Rect rect =
+          gfx::ToEnclosingRect(ScaleRect(paint_rect, 1.0f / contents_scale_));
+      if (!client_->GetInvalidation()->Intersects(rect)) {
+        tiles_[key] = candidate_tile;
+        return;
+      }
+    }
+  }
+
+  // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
   if (tile)
     tiles_[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) {
-  if (layer_bounds_ == layer_bounds)
-    return;
-
-  gfx::Size old_layer_bounds = layer_bounds_;
-  layer_bounds_ = layer_bounds;
-  gfx::Size old_content_bounds = tiling_data_.total_size();
-  gfx::Size content_bounds =
-      gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds_, contents_scale_));
-
-  tiling_data_.SetTotalSize(content_bounds);
-  if (layer_bounds_.IsEmpty()) {
-    tiles_.clear();
-    return;
-  }
-
-  gfx::Size tile_size = client_->CalculateTileSize(
-      tiling_data_.max_texture_size(),
-      content_bounds);
-  if (tile_size != tiling_data_.max_texture_size()) {
-    tiling_data_.SetMaxTextureSize(tile_size);
-    tiles_.clear();
-    CreateTilesFromLayerRect(gfx::Rect(layer_bounds_));
-    return;
-  }
-
-  // Any tiles outside our new bounds are invalid and should be dropped.
-  if (old_content_bounds.width() > content_bounds.width() ||
-      old_content_bounds.height() > content_bounds.height()) {
-    int right =
-        tiling_data_.TileXIndexFromSrcCoord(content_bounds.width() - 1);
-    int bottom =
-        tiling_data_.TileYIndexFromSrcCoord(content_bounds.height() - 1);
-
-    std::vector<TileMapKey> invalid_tile_keys;
-    for (TileMap::const_iterator it = tiles_.begin();
-         it != tiles_.end(); ++it) {
-      if (it->first.first > right || it->first.second > bottom)
-        invalid_tile_keys.push_back(it->first);
-    }
-    for (size_t i = 0; i < invalid_tile_keys.size(); ++i)
-      tiles_.erase(invalid_tile_keys[i]);
-  }
-
-  // Create tiles for newly exposed areas.
-  Region layer_region((gfx::Rect(layer_bounds_)));
-  layer_region.Subtract(gfx::Rect(old_layer_bounds));
-  for (Region::Iterator iter(layer_region); iter.has_rect(); iter.next()) {
-    Invalidate(iter.rect());
-    CreateTilesFromLayerRect(iter.rect());
-  }
-}
-
-void PictureLayerTiling::Invalidate(const Region& layer_invalidation) {
-  std::vector<TileMapKey> new_tiles;
-
-  for (Region::Iterator region_iter(layer_invalidation);
-       region_iter.has_rect();
-       region_iter.next()) {
-    gfx::Rect layer_invalidation = region_iter.rect();
-    layer_invalidation.Intersect(gfx::Rect(layer_bounds_));
-    gfx::Rect rect =
-        gfx::ToEnclosingRect(ScaleRect(layer_invalidation, contents_scale_));
-
-    for (PictureLayerTiling::Iterator tile_iter(this, contents_scale_, rect);
-         tile_iter;
-         ++tile_iter) {
-      TileMapKey key(tile_iter.tile_i_, tile_iter.tile_j_);
-      TileMap::iterator found = tiles_.find(key);
-      if (found == tiles_.end())
-        continue;
-
-      tiles_.erase(found);
-      new_tiles.push_back(key);
-    }
-  }
-
-  for (size_t i = 0; i < new_tiles.size(); ++i)
-    CreateTile(new_tiles[i].first, new_tiles[i].second);
-}
-
-void PictureLayerTiling::CreateTilesFromLayerRect(gfx::Rect layer_rect) {
-  gfx::Rect content_rect =
-      gfx::ToEnclosingRect(ScaleRect(layer_rect, contents_scale_));
-  CreateTilesFromContentRect(content_rect);
-}
-
-void PictureLayerTiling::CreateTilesFromContentRect(gfx::Rect content_rect) {
-  for (TilingData::Iterator iter(&tiling_data_, content_rect); iter; ++iter) {
-    TileMap::iterator found =
-        tiles_.find(TileMapKey(iter.index_x(), iter.index_y()));
-    // Ignore any tiles that already exist.
-    if (found != tiles_.end())
-      continue;
-    CreateTile(iter.index_x(), iter.index_y());
-  }
-}
-
 PictureLayerTiling::Iterator::Iterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
@@ skipping 129 matching lines @@
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
   texture_rect.Intersect(tiling_->ContentRect());
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::Iterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
+void PictureLayerTiling::Reset() {
+  live_tiles_rect_ = gfx::Rect();
+  tiles_.clear();
+}
+
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
     const gfx::RectF& viewport_in_layer_space,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
     float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
     const gfx::Transform& current_screen_transform,
     int current_source_frame_number,
     double current_frame_time,
     bool store_screen_space_quads_on_tiles,
     size_t max_tiles_for_interest_area) {
   if (ContentRect().IsEmpty())
     return;
 
+  gfx::Rect viewport_in_content_space =
+      gfx::ToEnclosingRect(gfx::ScaleRect(viewport_in_layer_space,
+                                          contents_scale_));
+
+  gfx::Size tile_size = tiling_data_.max_texture_size();
+  int64 interest_rect_area =
+      max_tiles_for_interest_area * tile_size.width() * tile_size.height();
+
+  gfx::Rect interest_rect = ExpandRectEquallyToAreaBoundedBy(
+      viewport_in_content_space,
+      interest_rect_area,
+      ContentRect());
+  DCHECK(ContentRect().Contains(interest_rect));
+
+  SetLiveTilesRect(interest_rect);
+
   bool first_update_in_new_source_frame =
       current_source_frame_number != last_source_frame_number_;
 
   bool first_update_in_new_impl_frame =
       current_frame_time != last_impl_frame_time_;
 
   // In pending tree, this is always called. We update priorities:
   // - Immediately after a commit (first_update_in_new_source_frame).
   // - On animation ticks after the first frame in the tree
   //   (first_update_in_new_impl_frame).
   // In active tree, this is only called during draw. We update priorities:
   // - On draw if properties were not already computed by the pending tree
   //   and activated for the frame (first_update_in_new_impl_frame).
   if (!first_update_in_new_impl_frame && !first_update_in_new_source_frame)
     return;
 
-  double time_delta = 0;
-  if (last_impl_frame_time_ != 0 && last_layer_bounds == current_layer_bounds)
+  double time_delta = 0.0;
+  if (last_impl_frame_time_ != 0.0 &&
+      last_layer_bounds == current_layer_bounds)
     time_delta = current_frame_time - last_impl_frame_time_;
 
-  gfx::Rect viewport_in_content_space =
-      gfx::ToEnclosingRect(gfx::ScaleRect(viewport_in_layer_space,
-                                          contents_scale_));
-
-  gfx::Size tile_size = tiling_data_.max_texture_size();
-  int64 prioritized_rect_area =
-      max_tiles_for_interest_area *
-      tile_size.width() * tile_size.height();
-
-  gfx::Rect prioritized_rect = ExpandRectEquallyToAreaBoundedBy(
-      viewport_in_content_space,
-      prioritized_rect_area,
-      ContentRect());
-  DCHECK(ContentRect().Contains(prioritized_rect));
-
-  // 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_,
-                                           prioritized_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();
-    tile->SetPriority(tree, priority);
-  }
-  last_prioritized_rect_ = prioritized_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_, prioritized_rect);
+    for (TilingData::Iterator iter(&tiling_data_, interest_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
       if (find == tiles_.end())
         continue;
       Tile* tile = find->second.get();
 
       gfx::Rect tile_bounds =
           tiling_data_.TileBounds(iter.index_x(), iter.index_y());
       gfx::RectF current_screen_rect = gfx::ScaleRect(
           tile_bounds,
@@ skipping 12 matching lines @@
               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->SetPriority(tree, priority);
     }
   } else {
-    for (TilingData::Iterator iter(&tiling_data_, prioritized_rect);
+    for (TilingData::Iterator iter(&tiling_data_, interest_rect);
          iter; ++iter) {
       TileMap::iterator find = tiles_.find(iter.index());
       if (find == tiles_.end())
         continue;
       Tile* tile = find->second.get();
 
       gfx::Rect tile_bounds =
           tiling_data_.TileBounds(iter.index_x(), iter.index_y());
       gfx::RectF current_layer_content_rect = gfx::ScaleRect(
           tile_bounds,
@@ skipping 27 matching lines @@
                               &clipped));
       }
       tile->SetPriority(tree, priority);
     }
   }
 
   last_source_frame_number_ = current_source_frame_number;
   last_impl_frame_time_ = current_frame_time;
 }
 
+void PictureLayerTiling::SetLiveTilesRect(
+    const gfx::Rect& new_live_tiles_rect) {
+  if (live_tiles_rect_ == new_live_tiles_rect)
+    return;
+
+  // Iterate to delete all tiles outside of our new live_tiles rect.
+  for (TilingData::DifferenceIterator iter(&tiling_data_,
+                                           live_tiles_rect_,
+                                           new_live_tiles_rect);
+      iter;
+      ++iter) {
+    TileMapKey key(iter.index());
+    TileMap::iterator found = tiles_.find(key);
+    if (found != tiles_.end() &&
+        !new_live_tiles_rect.Intersects(found->second->content_rect()))
+      tiles_.erase(found);
+  }
+
+  // Iterate to allocate new tiles for all regions with newly exposed area.
+  for (TilingData::DifferenceIterator iter(&tiling_data_,
+                                           new_live_tiles_rect,
+                                           live_tiles_rect_);
+      iter;
+      ++iter) {
+    TileMapKey key(iter.index());
+    TileMap::iterator found = tiles_.find(key);
+    CreateTile(key.first, key.second);
+  }
+
+  live_tiles_rect_ = new_live_tiles_rect;
+}
+
 void PictureLayerTiling::DidBecomeActive() {
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     it->second->SetPriority(ACTIVE_TREE, it->second->priority(PENDING_TREE));
     it->second->SetPriority(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
@@ skipping 105 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc