cc: Don't swap PictureLayerTilingSet on activate.

cc/resources/picture_layer_tiling_set.cc

Index: cc/resources/picture_layer_tiling_set.cc
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index 51896a5b5f7f29cfb287e970fb8b301aaa4b83a0..669e02e97f51224e4f7d86c823d5e1762219f677 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -40,15 +40,84 @@ PictureLayerTilingSet::PictureLayerTilingSet(PictureLayerTilingClient* client)
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
-void PictureLayerTilingSet::SetClient(PictureLayerTilingClient* client) {
-  client_ = client;
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->SetClient(client_);
+void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSource(
+    RasterSource* raster_source,
+    const gfx::Size& layer_bounds,
+    const Region& layer_invalidation,
+    float minimum_contents_scale) {
+  RemoveTilingsBelowScale(minimum_contents_scale);
+
+  for (PictureLayerTiling* tiling : tilings_) {
+    tiling->UpdateTilesToCurrentRasterSource(raster_source, layer_invalidation,
+                                             layer_bounds);
+    tiling->CreateMissingTilesInLiveTilesRect();
+
+    DCHECK(tiling->tile_size() ==
+           client_->CalculateTileSize(tiling->tiling_size()))
+        << "tile_size: " << tiling->tile_size().ToString()
+        << " tiling_size: " << tiling->tiling_size().ToString()
+        << " CalculateTileSize: "
+        << client_->CalculateTileSize(tiling->tiling_size()).ToString();
+  }
 }
 
-void PictureLayerTilingSet::RemoveTilesInRegion(const Region& region) {
-  for (size_t i = 0; i < tilings_.size(); ++i)
-    tilings_[i]->RemoveTilesInRegion(region);
+void PictureLayerTilingSet::UpdateTilingsFromPending(
+    RasterSource* raster_source,
+    const PictureLayerTilingSet& other,
+    const gfx::Size& layer_bounds,
+    const Region& layer_invalidation,
+    float minimum_contents_scale) {
+  DCHECK_EQ(ACTIVE_TREE, client_->GetTree());
+
+  RemoveTilingsBelowScale(minimum_contents_scale);
+
+  for (PictureLayerTiling* tiling : tilings_) {
+    // TODO(danakj): In the activate case can we do something simpler? Just copy
+    // things from the pending tree and share all the tiles?
+    tiling->UpdateTilesToCurrentRasterSource(raster_source, layer_invalidation,
+                                             layer_bounds);
+    // TODO(danakj): Is this needed anymore? Won't they already exist?
+    tiling->CreateMissingTilesInLiveTilesRect();
+    tiling->set_resolution(NON_IDEAL_RESOLUTION);
+
+    DCHECK(tiling->tile_size() ==
+           client_->CalculateTileSize(tiling->tiling_size()))
+        << "tile_size: " << tiling->tile_size().ToString()
+        << " tiling_size: " << tiling->tiling_size().ToString()
+        << " CalculateTileSize: "
+        << client_->CalculateTileSize(tiling->tiling_size()).ToString();
+  }
+
+  // Copy missing tilings, tiles and tiling resolutions from the pending tiling
+  // set.
+  for (PictureLayerTiling* pending_tiling : other.tilings_) {
+    float contents_scale = pending_tiling->contents_scale();
+    DCHECK_GE(contents_scale, minimum_contents_scale);
+
+    PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
+    if (!this_tiling) {
+      scoped_ptr<PictureLayerTiling> new_tiling =
+          PictureLayerTiling::Create(contents_scale, layer_bounds, client_);
+      tilings_.push_back(new_tiling.Pass());
+      this_tiling = tilings_.back();
+    }
+    this_tiling->CloneTilesAndPropertiesFrom(*pending_tiling);
+
+    DCHECK_EQ(pending_tiling->live_tiles_rect().ToString(),
+              this_tiling->live_tiles_rect().ToString());
+  }
+
+  tilings_.sort(LargestToSmallestScaleFunctor());
+
+#if DCHECK_IS_ON
+  if (!tilings_.empty()) {
+    size_t num_high_res = std::count_if(tilings_.begin(), tilings_.end(),
+                                        [](PictureLayerTiling* tiling) {
+      return tiling->resolution() == HIGH_RESOLUTION;
+    });
+    DCHECK_EQ(1u, num_high_res);
+  }
+#endif
 }
 
 void PictureLayerTilingSet::CleanUpTilings(
@@ -91,14 +160,6 @@ void PictureLayerTilingSet::CleanUpTilings(
   }
 
   for (auto* tiling : to_remove) {
-    PictureLayerTiling* twin_tiling =
-        twin_set ? twin_set->FindTilingWithScale(tiling->contents_scale())
-                 : nullptr;
-    // Only remove tilings from the twin layer if they have
-    // NON_IDEAL_RESOLUTION.
-    if (twin_tiling && twin_tiling->resolution() == NON_IDEAL_RESOLUTION)
-      twin_set->Remove(twin_tiling);
-
     PictureLayerTiling* recycled_twin_tiling =
         recycled_twin_set
             ? recycled_twin_set->FindTilingWithScale(tiling->contents_scale())
@@ -113,16 +174,24 @@ void PictureLayerTilingSet::CleanUpTilings(
   }
 }
 
+void PictureLayerTilingSet::RemoveNonIdealTilings() {
+  auto to_remove = tilings_.remove_if([](PictureLayerTiling* t) -> bool {
+    return t->resolution() == NON_IDEAL_RESOLUTION;
+  });
+  tilings_.erase(to_remove, tilings_.end());
+}
+
 void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
   for (auto* tiling : tilings_)
     tiling->set_resolution(NON_IDEAL_RESOLUTION);
 }
 
-bool PictureLayerTilingSet::SyncTilings(const PictureLayerTilingSet& other,
-                                        const gfx::Size& new_layer_bounds,
-                                        const Region& layer_invalidation,
-                                        float minimum_contents_scale,
-                                        RasterSource* raster_source) {
+bool PictureLayerTilingSet::SyncTilingsForTesting(
+    const PictureLayerTilingSet& other,
+    const gfx::Size& new_layer_bounds,
+    const Region& layer_invalidation,
+    float minimum_contents_scale,
+    RasterSource* raster_source) {
   if (new_layer_bounds.IsEmpty()) {
     RemoveAllTilings();
     return false;
@@ -222,6 +291,14 @@ PictureLayerTiling* PictureLayerTilingSet::FindTilingWithResolution(
   return *iter;
 }
 
+void PictureLayerTilingSet::RemoveTilingsBelowScale(float minimum_scale) {
+  auto to_remove =
+      tilings_.remove_if([minimum_scale](PictureLayerTiling* tiling) -> bool {
+        return tiling->contents_scale() < minimum_scale;
+      });
+  tilings_.erase(to_remove, tilings_.end());
+}
+
 void PictureLayerTilingSet::RemoveAllTilings() {
   tilings_.clear();
 }