Activate LayerImpl tree with sync+push instead of pointer swap

cc/layer_tree_host_impl.cc

 // Copyright 2011 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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 21 matching lines @@
 #include "cc/render_pass_draw_quad.h"
 #include "cc/rendering_stats.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/shared_quad_state.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/software_renderer.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_uploader.h"
 #include "cc/top_controls_manager.h"
+#include "cc/tree_synchronizer.h"
 #include "cc/util.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
@@ skipping 115 matching lines @@
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
 
     if (rootLayer()) {
         clearRenderSurfaces();
         // The layer trees must be destroyed before the layer tree host. We've
         // made a contract with our animation controllers that the registrar
         // will outlive them, and we must make good.
+        m_recycleTree.reset();
+        m_pendingTree.reset();
         m_activeTree.reset();
-        m_pendingTree.reset();
     }
 }
 
 void LayerTreeHostImpl::beginCommit()
 {
 }
 
 void LayerTreeHostImpl::commitComplete()
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
 
     // Impl-side painting needs an update immediately post-commit to have the
     // opportunity to create tilings.  Other paths can call updateDrawProperties
     // more lazily when needed prior to drawing.
     setNeedsUpdateDrawProperties();
     if (m_settings.implSidePainting)
         updateDrawProperties();
 
-    // Recompute max scroll position; must be after layer content bounds are
-    // updated.
-    updateMaxScrollOffset();
     m_client->sendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::canDraw()
 {
     // Note: If you are changing this function or any other function that might
     // affect the result of canDraw, make sure to call m_client->onCanDrawStateChanged
     // in the proper places and update the notifyIfCanDrawChanged test.
 
     if (!rootLayer()) {
@@ skipping 715 matching lines @@
 
     if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
         return layerImpl->parent();
 
     return 0;
 }
 
 void LayerTreeHostImpl::createPendingTree()
 {
     CHECK(!m_pendingTree);
-    m_pendingTree = LayerTreeImpl::create(this);
+    if (m_recycleTree)
+        m_recycleTree.swap(m_pendingTree);
+    else
+        m_pendingTree = LayerTreeImpl::create(this);
     m_client->onCanDrawStateChanged(canDraw());
     m_client->onHasPendingTreeStateChanged(pendingTree());
 }
 
 void LayerTreeHostImpl::checkForCompletedTileUploads()
 {
     DCHECK(!m_client->isInsideDraw()) << "Checking for completed uploads within a draw may trigger spurious redraws.";
     if (m_tileManager)
         m_tileManager->CheckForCompletedTileUploads();
 }
@@ skipping 10 matching lines @@
       return;
 
     activatePendingTree();
 }
 
 void LayerTreeHostImpl::activatePendingTree()
 {
     CHECK(m_pendingTree);
 
     m_activeTree->PushPersistedState(m_pendingTree.get());
-    m_activeTree.swap(m_pendingTree);
-    // TODO(enne): consider recycling this tree to prevent layer churn
-    m_pendingTree.reset();
+    m_activeTree->SetRootLayer(TreeSynchronizer::synchronizeTrees(m_pendingTree->RootLayer(), m_activeTree->DetachLayerTree(), m_activeTree.get()));
+    TreeSynchronizer::pushProperties(m_pendingTree->RootLayer(), m_activeTree->RootLayer());
+    DCHECK(!m_recycleTree);
+
+    // This should match the property synchronization in
+    // LayerTreeHost::finishCommitOnImplThread().
+    m_activeTree->set_source_frame_number(m_pendingTree->source_frame_number());
+    m_activeTree->set_background_color(m_pendingTree->background_color());
+    m_activeTree->set_has_transparent_background(m_pendingTree->has_transparent_background());
+    if (m_pendingTree->ContentsTexturesPurged())
+        m_activeTree->SetContentsTexturesPurged();
+    else
+        m_activeTree->ResetContentsTexturesPurged();
+
+    // Now that we've synced everything from the pending tree to the active
+    // tree, rename the pending tree the recycle tree so we can reuse it on the
+    // next sync.
+    m_pendingTree.swap(m_recycleTree);
+    m_recycleTree->ClearRenderSurfaces();
+
     m_activeTree->DidBecomeActive();
 
     m_client->onCanDrawStateChanged(canDraw());
     m_client->onHasPendingTreeStateChanged(pendingTree());
     m_client->setNeedsRedrawOnImplThread();
     m_client->renewTreePriority();
 }
 
 void LayerTreeHostImpl::setVisible(bool visible)
 {
@@ skipping 17 matching lines @@
 {
     // Since we will create a new resource provider, we cannot continue to use
     // the old resources (i.e. renderSurfaces and texture IDs). Clear them
     // before we destroy the old resource provider.
     if (rootLayer())
         clearRenderSurfaces();
     if (activeTree()->RootLayer())
         sendDidLoseOutputSurfaceRecursive(activeTree()->RootLayer());
     if (pendingTree() && pendingTree()->RootLayer())
         sendDidLoseOutputSurfaceRecursive(pendingTree()->RootLayer());
+    if (m_recycleTree && m_recycleTree->RootLayer())
+        sendDidLoseOutputSurfaceRecursive(m_recycleTree->RootLayer());
 
     // Note: order is important here.
     m_renderer.reset();
     m_tileManager.reset();
     m_resourceProvider.reset();
     m_outputSurface.reset();
 
     if (!outputSurface->BindToClient(this))
         return false;
 
@@ skipping 94 matching lines @@
 void LayerTreeHostImpl::setPageScaleDelta(float delta)
 {
     m_pinchZoomViewport.set_page_scale_delta(delta);
 
     updateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::updateMaxScrollOffset()
 {
     activeTree()->UpdateMaxScrollOffset();
-    if (pendingTree())
-        pendingTree()->UpdateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::setNeedsUpdateDrawProperties()
 {
     m_needsUpdateDrawProperties = true;
 }
 
 void LayerTreeHostImpl::setNeedsRedraw()
 {
     m_client->setNeedsRedrawOnImplThread();
@@ skipping 562 matching lines @@
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime)
 {
     m_paintTimeCounter->SavePaintTime(totalPaintTime);
 }
 
 }  // namespace cc