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),
-      contents_scale_(contents_scale),
+PictureLayerTiling::PictureLayerTiling(float contents_scale,
+                                       gfx::Size layer_bounds,
+                                       PictureLayerTilingClient* client)
+    : contents_scale_(contents_scale),
+      layer_bounds_(layer_bounds),
+      resolution_(NON_IDEAL_RESOLUTION),
+      client_(client),
       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)
+{
+  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);
+  TileMapKey key(i, j);
+  tiles_.erase(key);

[enne (OOO), 2013/04/10 20:25:30]

I liked the dcheck better.

[whunt, 2013/04/10 20:52:30]

The DCHECK is wrong given the way that SetLiveTilesRect works.  If we grow
slightly nothing gets deleted because there are no regions that were previously
exposed that aren't any more.  Because the grown regions need to be repainted
this code handles that during the second loop that creates tiles for newly
exposed regions.

[enne (OOO), 2013/04/10 21:21:24]

What do you mean by grow slightly? I thought all the layer size changes were
handled by passing the layer size to the constructor.

[whunt, 2013/04/10 21:45:59]

I mean grow the interest rect.  We use difference iterators over the new and old
interest rects, we delete things in the difference between old - new and add
things in new - old.  However, some of the tiles in the new - old region already
exist but are not fully painted... oohh they're all always painted right because
we don't have a SetLayerBounds call anymore?

+
+  gfx::Rect paint_rect = tiling_data_.TileBoundsWithBorder(i, j);
+  gfx::Rect tile_rect = paint_rect;
   tile_rect.set_size(tiling_data_.max_texture_size());
-  TileMapKey key(i, j);
-  DCHECK(tiles_.find(key) == tiles_.end());
+
+  // 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::CoverageIterator 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::InvalidateTilesWithText() {
   std::vector<TileMapKey> new_tiles;
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
     if (it->second->has_text())
       new_tiles.push_back(it->first);
   }
 
   for (size_t i = 0; i < new_tiles.size(); ++i) {
     tiles_.erase(new_tiles[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::CoverageIterator::CoverageIterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
@@ skipping 132 matching lines @@
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
   texture_rect.Intersect(tiling_->ContentRect());
 
   return texture_rect;
 }
 
 gfx::Size PictureLayerTiling::CoverageIterator::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_input) {

[enne (OOO), 2013/04/10 20:25:30]

This function should take a gfx::Rect by value.

+  gfx::Rect new_live_tiles_rect = new_live_tiles_rect_input;
+  gfx::Rect content_rect =

[enne (OOO), 2013/04/10 20:25:30]

I'd really rather just dcheck this than intersect twice.

[whunt, 2013/04/10 20:52:30]

If SetLiveTilesRect can be made private we can use the DCHECK, otherwise it
needs to stay the way it is.  I'll look into it.

+      gfx::ToEnclosingRect(gfx::ScaleRect(gfx::Rect(layer_bounds_),
+                                          contents_scale_));
+  new_live_tiles_rect.Intersect(content_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()) {

[enne (OOO), 2013/04/10 20:25:30]

This change seems unnecessary.

[whunt, 2013/04/10 20:52:30]

It was introduced during debugging and can be deleted.

+      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());
+    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