Activate LayerImpl tree with sync+push instead of pointer swap

cc/picture_layer_impl.cc

Index: cc/picture_layer_impl.cc
diff --git a/cc/picture_layer_impl.cc b/cc/picture_layer_impl.cc
index 2aef705e60c6ab235cb63ed56b23805b69193d4e..d8093ca2875dd55c7cb543563a2946576bb464f6 100644
--- a/cc/picture_layer_impl.cc
+++ b/cc/picture_layer_impl.cc
@@ -25,7 +25,7 @@ namespace cc {
 
 PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* treeImpl, int id)
     : LayerImpl(treeImpl, id),
-      tilings_(this),
+      tilings_(new PictureLayerTilingSet(this)),
       pile_(PicturePileImpl::Create()),
       last_update_time_(0),
       last_content_scale_(0),
@@ -40,6 +40,23 @@ const char* PictureLayerImpl::layerTypeAsString() const {
   return "PictureLayer";
 }
 
+scoped_ptr<LayerImpl> PictureLayerImpl::createLayerImpl(
+    LayerTreeImpl* treeImpl) {
+  return PictureLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
+}
+
+void PictureLayerImpl::pushPropertiesTo(LayerImpl* base_layer) {
+  LayerImpl::pushPropertiesTo(base_layer);
+
+  PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
+  layer_impl->SetIsMask(is_mask_);
+  layer_impl->tilings_.swap(tilings_);
+  tilings_.reset(new PictureLayerTilingSet(this));
+  layer_impl->pile_ = pile_;
+  pile_ = PicturePileImpl::Create();
+}
+
+
 void PictureLayerImpl::appendQuads(QuadSink& quadSink,
                                    AppendQuadsData& appendQuadsData) {
 
@@ -57,7 +74,7 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
   bool useAA = !isAxisAlignedInTarget;
 
   if (showDebugBorders()) {
-    for (PictureLayerTilingSet::Iterator iter(&tilings_,
+    for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                               contentsScaleX(),
                                               rect,
                                               ideal_contents_scale_);
@@ -85,7 +102,7 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
-  for (PictureLayerTilingSet::Iterator iter(&tilings_,
+  for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             contentsScaleX(),
                                             rect,
                                             ideal_contents_scale_);
@@ -163,7 +180,7 @@ void PictureLayerImpl::didUpdateTransforms() {
     time_delta = current_time - last_update_time_;
   }
   WhichTree tree = layerTreeImpl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
-  tilings_.UpdateTilePriorities(
+  tilings_->UpdateTilePriorities(
       tree,
       layerTreeImpl()->device_viewport_size(),
       last_content_scale_,
@@ -180,11 +197,12 @@ void PictureLayerImpl::didUpdateTransforms() {
 }
 
 void PictureLayerImpl::didBecomeActive() {
-  tilings_.MoveTilePriorities(PENDING_TREE, ACTIVE_TREE);
+  LayerImpl::didBecomeActive();
+  tilings_->MoveTilePriorities(PENDING_TREE, ACTIVE_TREE);
 }
 
 void PictureLayerImpl::didLoseOutputSurface() {
-  tilings_.RemoveAllTilings();
+  tilings_->RemoveAllTilings();
 }
 
 void PictureLayerImpl::calculateContentsScale(
@@ -193,7 +211,7 @@ void PictureLayerImpl::calculateContentsScale(
     float* contents_scale_y,
     gfx::Size* content_bounds) {
   if (!drawsContent()) {
-    DCHECK(!tilings_.num_tilings());
+    DCHECK(!tilings_->num_tilings());
     return;
   }
 
@@ -209,8 +227,8 @@ void PictureLayerImpl::calculateContentsScale(
   // tilings (and then map back to floating point texture coordinates), the
   // contents scale must be at least as large as the largest of the tilings.
   float max_contents_scale = min_contents_scale;
-  for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
-    const PictureLayerTiling* tiling = tilings_.tiling_at(i);
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    const PictureLayerTiling* tiling = tilings_->tiling_at(i);
     max_contents_scale = std::max(max_contents_scale, tiling->contents_scale());
   }
 
@@ -253,25 +271,25 @@ void PictureLayerImpl::SyncFromActiveLayer() {
 }
 
 void PictureLayerImpl::SyncFromActiveLayer(const PictureLayerImpl* other) {
-  tilings_.CloneAll(other->tilings_, invalidation_);
+  tilings_->CloneAll(*other->tilings_, invalidation_);
 }
 
 void PictureLayerImpl::SyncTiling(
     const PictureLayerTiling* tiling) {
-  tilings_.Clone(tiling, invalidation_);
+  tilings_->Clone(tiling, invalidation_);
 }
 
 void PictureLayerImpl::SetIsMask(bool is_mask) {
   if (is_mask_ == is_mask)
     return;
   is_mask_ = is_mask;
-  tilings_.RemoveAllTiles();
+  tilings_->RemoveAllTiles();
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::contentsResourceId() const {
   gfx::Rect content_rect(gfx::Point(), contentBounds());
   float scale = contentsScaleX();
-  for (PictureLayerTilingSet::Iterator iter(&tilings_,
+  for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
                                             scale,
                                             content_rect,
                                             ideal_contents_scale_);
@@ -291,8 +309,8 @@ ResourceProvider::ResourceId PictureLayerImpl::contentsResourceId() const {
 bool PictureLayerImpl::areVisibleResourcesReady() const {
   const gfx::Rect& rect = visibleContentRect();
 
-  for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
-    const PictureLayerTiling* tiling = tilings_.tiling_at(i);
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    const PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     // Ignore non-high resolution tilings.
     if (tiling->resolution() != HIGH_RESOLUTION)
@@ -316,7 +334,7 @@ PictureLayerTiling* PictureLayerImpl::AddTiling(float contents_scale) {
   if (contents_scale < layerTreeImpl()->settings().minimumContentsScale)
     return NULL;
 
-  PictureLayerTiling* tiling = tilings_.AddTiling(
+  PictureLayerTiling* tiling = tilings_->AddTiling(
       contents_scale,
       TileSize());
 
@@ -377,8 +395,8 @@ void PictureLayerImpl::ManageTilings(float ideal_contents_scale) {
   if (layerTreeImpl()->IsPendingTree() &&
       !layerTreeImpl()->PinchGestureActive()) {
     std::vector<PictureLayerTiling*> remove_list;
-    for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
-      PictureLayerTiling* tiling = tilings_.tiling_at(i);
+    for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+      PictureLayerTiling* tiling = tilings_->tiling_at(i);
       if (tiling->contents_scale() == ideal_contents_scale)
         continue;
       if (tiling->contents_scale() == low_res_contents_scale)
@@ -387,14 +405,14 @@ void PictureLayerImpl::ManageTilings(float ideal_contents_scale) {
     }
 
     for (size_t i = 0; i < remove_list.size(); ++i)
-      tilings_.Remove(remove_list[i]);
+      tilings_->Remove(remove_list[i]);
   }
 
   // Find existing tilings closest to ideal high / low res.
   PictureLayerTiling* high_res = NULL;
   PictureLayerTiling* low_res = NULL;
-  for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_.tiling_at(i);
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = tilings_->tiling_at(i);
     if (!high_res || IsCloserToThan(tiling, high_res, ideal_contents_scale))
       high_res = tiling;
     if (!low_res || IsCloserToThan(tiling, low_res, low_res_contents_scale))
@@ -438,8 +456,8 @@ void PictureLayerImpl::CleanUpUnusedTilings(
     std::vector<PictureLayerTiling*> used_tilings) {
   std::vector<PictureLayerTiling*> to_remove;
 
-  for (size_t i = 0; i < tilings_.num_tilings(); ++i) {
-    PictureLayerTiling* tiling = tilings_.tiling_at(i);
+  for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = tilings_->tiling_at(i);
     // Don't remove the current high or low res tilinig.
     if (tiling->resolution() != NON_IDEAL_RESOLUTION)
       continue;
@@ -449,7 +467,7 @@ void PictureLayerImpl::CleanUpUnusedTilings(
   }
 
   for (size_t i = 0; i < to_remove.size(); ++i)
-    tilings_.Remove(to_remove[i]);
+    tilings_->Remove(to_remove[i]);
 }
 
 }  // namespace cc