Makes tile-creation lazy

cc/resources/picture_layer_tiling_set.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_set.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 16 matching lines @@
 }
 
 void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
   client_ = client;
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->SetClient(client_);
 }
 
 void PictureLayerTilingSet::CloneAll(
     const PictureLayerTilingSet& other,
-    const Region& invalidation,
     float minimum_contents_scale) {
   tilings_.clear();
   tilings_.reserve(other.tilings_.size());
   for (size_t i = 0; i < other.tilings_.size(); ++i) {
     if (other.tilings_[i]->contents_scale() < minimum_contents_scale)
       continue;
-    Clone(other.tilings_[i], invalidation);
+    Clone(other.tilings_[i]);
   }
 }
 
 void PictureLayerTilingSet::Clone(
-    const PictureLayerTiling* tiling,
-    const Region& invalidation) {
+    const PictureLayerTiling* tiling) {

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

style nit: this can fit on one line now.

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

Done.

 
   for (size_t i = 0; i < tilings_.size(); ++i)
     DCHECK_NE(tilings_[i]->contents_scale(), tiling->contents_scale());
 
   tilings_.push_back(tiling->Clone());
   gfx::Size size = tilings_.back()->layer_bounds();
   tilings_.back()->SetClient(client_);
-  tilings_.back()->Invalidate(invalidation);
   // Intentionally use this set's layer bounds, as it may have changed.
   tilings_.back()->SetLayerBounds(layer_bounds_);
 
   tilings_.sort(LargestToSmallestScaleFunctor());
 }
 
 void PictureLayerTilingSet::SetLayerBounds(gfx::Size layer_bounds) {
   if (layer_bounds_ == layer_bounds)
     return;
   layer_bounds_ = layer_bounds;
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->SetLayerBounds(layer_bounds);
 }
 
 gfx::Size PictureLayerTilingSet::LayerBounds() const {
   return layer_bounds_;
 }
 
-void PictureLayerTilingSet::Invalidate(const Region& layer_invalidation) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->Invalidate(layer_invalidation);
-}
-
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(float contents_scale) {
   tilings_.push_back(PictureLayerTiling::Create(contents_scale));
   PictureLayerTiling* appended = tilings_.back();
   appended->SetClient(client_);
   appended->SetLayerBounds(layer_bounds_);
 
   tilings_.sort(LargestToSmallestScaleFunctor());
   return appended;
 }
 
 void PictureLayerTilingSet::RemoveAllTilings() {
   tilings_.clear();
 }
 
 void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
   ScopedPtrVector<PictureLayerTiling>::iterator iter =
     std::find(tilings_.begin(), tilings_.end(), tiling);
   if (iter == tilings_.end())
     return;
   tilings_.erase(iter);
 }
 
 void PictureLayerTilingSet::RemoveAllTiles() {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->Reset();
 }
 
-void PictureLayerTilingSet::CreateTilesFromLayerRect(gfx::Rect layer_rect) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->CreateTilesFromLayerRect(layer_rect);
-}
-
 PictureLayerTilingSet::Iterator::Iterator(
     const PictureLayerTilingSet* set,
     float contents_scale,
     gfx::Rect content_rect,
     float ideal_contents_scale)
     : set_(set),
       contents_scale_(contents_scale),
       ideal_contents_scale_(ideal_contents_scale),
       current_tiling_(-1) {
   missing_region_.Union(content_rect);
@@ skipping 182 matching lines @@
 }
 
 scoped_ptr<base::Value> PictureLayerTilingSet::AsValue() const {
   scoped_ptr<base::ListValue> state(new base::ListValue());
   for (size_t i = 0; i < tilings_.size(); ++i)
     state->Append(tilings_[i]->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc