Makes tile-creation lazy

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 
 #include "base/time.h"
 #include "cc/base/math_util.h"
@@ skipping 72 matching lines @@
   pile_ = PicturePileImpl::Create(is_using_lcd_text_);
 
   layer_impl->raster_page_scale_ = raster_page_scale_;
   layer_impl->raster_device_scale_ = raster_device_scale_;
   layer_impl->raster_source_scale_ = raster_source_scale_;
   layer_impl->raster_contents_scale_ = raster_contents_scale_;
   layer_impl->low_res_raster_contents_scale_ = low_res_raster_contents_scale_;
   layer_impl->is_using_lcd_text_ = is_using_lcd_text_;
 }
 
-
 void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   const gfx::Rect& rect = visible_content_rect();
   gfx::Rect content_rect(content_bounds());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   bool clipped = false;
@@ skipping 261 matching lines @@
       content_rect,
       contents_opaque() ? content_rect : gfx::Rect(),
       tiling->contents_scale(),
       id()));
 }
 
 void PictureLayerImpl::UpdatePile(Tile* tile) {
   tile->set_picture_pile(pile_);
 }
 
+const Region* PictureLayerImpl::GetInvalidation() {
+  return &invalidation_;
+}
+
+const PictureLayerTiling* PictureLayerImpl::GetTwinTiling(
+    const PictureLayerTiling* tiling) {
+
+  const PictureLayerImpl* other_layer = layer_tree_impl()->IsActiveTree() ?
+      PendingTwin() : ActiveTwin();
+  if (!other_layer)
+    return NULL;
+  for (size_t i = 0; i < other_layer->tilings_->num_tilings(); ++i)
+    if (other_layer->tilings_->tiling_at(i)->contents_scale() ==
+        tiling->contents_scale())
+      return other_layer->tilings_->tiling_at(i);
+  return NULL;
+}
+
 gfx::Size PictureLayerImpl::CalculateTileSize(
     gfx::Size current_tile_size,
     gfx::Size content_bounds) {
   if (is_mask_) {
     int max_size = layer_tree_impl()->MaxTextureSize();
     return gfx::Size(
         std::min(max_size, content_bounds.width()),
         std::min(max_size, content_bounds.height()));
   }
 
@@ skipping 72 matching lines @@
     for (int y = 0; y < pile_->num_tiles_y(); ++y) {
       bool previously_had = other->pile_->HasRecordingAt(x, y);
       bool now_has = pile_->HasRecordingAt(x, y);
       if (now_has || !previously_had)
         continue;
       gfx::Rect layer_rect = pile_->tile_bounds(x, y);
       invalidation_.Union(layer_rect);
     }
   }
 
-  tilings_->CloneAll(*other->tilings_, invalidation_, MinimumContentsScale());
+  // Union in the other newly exposed regions as invalid.
+  Region difference_region = Region(gfx::Rect(bounds()));
+  difference_region.Subtract(gfx::Rect(other->bounds()));
+  invalidation_.Union(difference_region);
+
+  tilings_->CloneAll(*other->tilings_, MinimumContentsScale());
   DCHECK(bounds() == tilings_->LayerBounds());
-
-  // It's a sad but unfortunate fact that PicturePile tiling edges do not line
-  // up with PictureLayerTiling edges.  Tiles can only be added if they are
-  // entirely covered by recordings (that may come from multiple PicturePile
-  // tiles).  This check happens in this class's CreateTile() call.
-  for (int x = 0; x < pile_->num_tiles_x(); ++x) {
-    for (int y = 0; y < pile_->num_tiles_y(); ++y) {
-      bool previously_had = other->pile_->HasRecordingAt(x, y);
-      bool now_has = pile_->HasRecordingAt(x, y);
-      if (!now_has || previously_had)
-        continue;
-      gfx::Rect layer_rect = pile_->tile_bounds(x, y);
-      tilings_->CreateTilesFromLayerRect(layer_rect);
-    }
-  }
 }
 
 void PictureLayerImpl::SyncTiling(
-    const PictureLayerTiling* tiling,
-    const Region& pending_layer_invalidation) {
+    const PictureLayerTiling* tiling) {
   if (!DrawsContent() || tiling->contents_scale() < MinimumContentsScale())
     return;
-  tilings_->Clone(tiling, pending_layer_invalidation);
+  tilings_->Clone(tiling);
 }
 
 void PictureLayerImpl::SetIsMask(bool is_mask) {
   if (is_mask_ == is_mask)
     return;
   is_mask_ = is_mask;
   if (tilings_)
     tilings_->RemoveAllTiles();
 }
 
@@ skipping 62 matching lines @@
 }
 
 PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   DCHECK(contents_scale >= MinimumContentsScale());
 
   PictureLayerTiling* tiling = tilings_->AddTiling(contents_scale);
 
   const Region& recorded = pile_->recorded_region();
   DCHECK(!recorded.IsEmpty());
 
-  for (Region::Iterator iter(recorded); iter.has_rect(); iter.next())
-    tiling->CreateTilesFromLayerRect(iter.rect());
-
   PictureLayerImpl* twin =
       layer_tree_impl()->IsPendingTree() ? ActiveTwin() : PendingTwin();
   if (!twin)
     return tiling;
 
   if (layer_tree_impl()->IsPendingTree())

[enne (OOO), 2013/03/29 20:50:58]

This if statement can be simplified.

[whunt, 2013/03/29 21:52:04]

Clearly. I'll go do that.

-    twin->SyncTiling(tiling, invalidation_);
+    twin->SyncTiling(tiling);
   else
-    twin->SyncTiling(tiling, twin->invalidation_);
+    twin->SyncTiling(tiling);
 
   return tiling;
 }
 
 void PictureLayerImpl::RemoveTiling(float contents_scale) {
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (tiling->contents_scale() == contents_scale) {
       tilings_->Remove(tiling);
       break;
@@ skipping 245 matching lines @@
       layer_tree_impl()->IsActiveTree() ? PendingTwin() : this;
   if (layer_tree_impl()->IsActiveTree() &&
       pending_layer->is_using_lcd_text_ == is_using_lcd_text_)
     return;
 
   // Further tiles created due to new tilings should be considered invalidated.
   pending_layer->invalidation_.Union(gfx::Rect(bounds()));
   pending_layer->is_using_lcd_text_ = is_using_lcd_text_;
   pending_layer->pile_ = PicturePileImpl::CreateFromOther(pending_layer->pile_,
                                                           is_using_lcd_text_);
-
-  // TODO(enne): if we tracked text regions, we could just invalidate those
-  // directly rather than tossing away every tile.
-  pending_layer->tilings_->Invalidate(gfx::Rect(bounds()));

[enne (OOO), 2013/03/29 20:50:58]

This is incorrect to remove wholesale.  Invalidate both deletes and creates new
tiles.  Your patch defers creation, but I think you still need to somehow do the
deletion here because there now a bunch of tiles that need to be rerastered.

[whunt, 2013/03/29 21:52:04]

Good call, I'll investigate the best way to keep the correct behavior.

[whunt, 2013/03/29 22:17:55]

On second thought, I'm not actually sure, we should discuss.

 }
 
 void PictureLayerImpl::GetDebugBorderProperties(
     SkColor* color,
     float* width) const {
   *color = DebugColors::TiledContentLayerBorderColor();
   *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
 
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc