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"
 
 #include <limits>
 
 namespace cc {
 
 namespace {
 
 class LargestToSmallestScaleFunctor {
  public:
   bool operator() (PictureLayerTiling* left, PictureLayerTiling* right) {
     return left->contents_scale() > right->contents_scale();
   }
 };
 
 }  // namespace
 
 
 PictureLayerTilingSet::PictureLayerTilingSet(
-    PictureLayerTilingClient * client)
-    : client_(client) {
+    PictureLayerTilingClient* client,
+    gfx::Size layer_bounds)
+    : client_(client),
+      layer_bounds_(layer_bounds) {
 }
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
 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)
+    const PictureLayerTiling* tiling = other.tilings_[i];
+    if (tiling->contents_scale() < minimum_contents_scale)
       continue;
-    Clone(other.tilings_[i], invalidation);
+    tilings_.push_back(tiling->Clone(layer_bounds_, client_));
   }
+  tilings_.sort(LargestToSmallestScaleFunctor());
 }
 
-void PictureLayerTilingSet::Clone(
-    const PictureLayerTiling* tiling,
-    const Region& invalidation) {
-
+void PictureLayerTilingSet::Clone(const PictureLayerTiling* tiling) {
   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_.push_back(tiling->Clone(layer_bounds_, client_));
   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);
-}
-
 void PictureLayerTilingSet::InvalidateTilesWithText() {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->InvalidateTilesWithText();
 }
 
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(float contents_scale) {
-  tilings_.push_back(PictureLayerTiling::Create(contents_scale));
+  tilings_.push_back(PictureLayerTiling::Create(contents_scale,
+                                                layer_bounds_,
+                                                client_));
   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::CoverageIterator::CoverageIterator(
     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 187 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