[cc] Move root layer pointer to LayerTreeImpl

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 185 matching lines @@
 }
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::create(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
 {
     return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
 }
 
 LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
     : m_client(client)
     , m_proxy(proxy)
-    , m_sourceFrameNumber(-1)
-    , m_rootScrollLayerImpl(0)
-    , m_currentlyScrollingLayerImpl(0)
-    , m_hudLayerImpl(0)
-    , m_scrollingLayerIdFromPreviousTree(-1)
     , m_scrollDeltaIsInViewportSpace(false)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             PriorityCalculator::allowEverythingCutoff(),
                             0,
                             PriorityCalculator::allowNothingCutoff())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(FrameRateCounter::create(m_proxy->hasImplThread()))
     , m_debugRectHistory(DebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
+
+    // TODO(nduca): For now, assume we have an active tree. This will be removed
+    // in future patches.
+    m_activeTree = LayerTreeImpl::create(this);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
 
-    if (m_rootLayerImpl)
+    if (rootLayer())
         clearRenderSurfaces();
 }
 
 void LayerTreeHostImpl::beginCommit()
 {
 }
 
 void LayerTreeHostImpl::commitComplete()
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
     // 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 (!m_rootLayerImpl) {
+    if (!rootLayer()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no root layer");
         return false;
     }
     if (deviceViewportSize().IsEmpty()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw empty viewport");
         return false;
     }
     if (!m_renderer) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no renderer");
         return false;
@@ skipping 18 matching lines @@
 }
 
 void LayerTreeHostImpl::manageTiles()
 {
     DCHECK(m_tileManager);
     m_tileManager->ManageTiles();
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
-    if (!m_rootScrollLayerImpl)
+    if (!rootScrollLayer())
         return;
 
-    gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
+    gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     gfx::SizeF scaledContentSize = contentSize();
     if (!m_settings.pageScalePinchZoomEnabled) {
         scrollTotal.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
         scaledContentSize.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
     }
     gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
     m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, m_pinchZoomViewport.totalPageScaleFactor(), viewportSize, scaledContentSize, startTimeSeconds);
 
@@ skipping 42 matching lines @@
     for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
         RenderSurfaceImpl* renderSurface = renderSurfaceLayer->renderSurface();
         DCHECK(renderSurface);
         renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnlyFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
     }
 }
 
 void LayerTreeHostImpl::updateRootScrollLayerImplTransform()
 {
-    if (m_rootScrollLayerImpl) {
-        m_rootScrollLayerImpl->setImplTransform(implTransform());
+    if (rootScrollLayer()) {
+        rootScrollLayer()->setImplTransform(implTransform());
     }
 }
 
 void LayerTreeHostImpl::calculateRenderSurfaceLayerList(LayerList& renderSurfaceLayerList)
 {
     DCHECK(renderSurfaceLayerList.empty());
-    DCHECK(m_rootLayerImpl);
+    DCHECK(rootLayer());
     DCHECK(m_renderer); // For maxTextureSize.
 
     {
         updateRootScrollLayerImplTransform();
 
         TRACE_EVENT0("cc", "LayerTreeHostImpl::calcDrawEtc");
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
-        LayerTreeHostCommon::calculateDrawProperties(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, pageScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
+        LayerTreeHostCommon::calculateDrawProperties(rootLayer(), deviceViewportSize(), m_deviceScaleFactor, pageScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
 
-        trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList);
+        trackDamageForAllSurfaces(rootLayer(), renderSurfaceLayerList);
     }
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     RenderPass* pass = renderPass.get();
     renderPasses.push_back(pass);
     renderPassesById.set(pass->id, renderPass.Pass());
 }
 
@@ skipping 90 matching lines @@
 
     TRACE_EVENT1("cc", "LayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
 
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
         renderSurfaceLayer->renderSurface()->appendRenderPasses(frame);
     }
 
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
-    OcclusionTrackerImpl occlusionTracker(m_rootLayerImpl->renderSurface()->contentRect(), recordMetricsForFrame);
+    OcclusionTrackerImpl occlusionTracker(rootLayer()->renderSurface()->contentRect(), recordMetricsForFrame);
     occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
 
     if (m_debugState.showOccludingRects)
         occlusionTracker.setOccludingScreenSpaceRectsContainer(&frame.occludingScreenSpaceRects);
     if (m_debugState.showNonOccludingRects)
         occlusionTracker.setNonOccludingScreenSpaceRectsContainer(&frame.nonOccludingScreenSpaceRects);
 
     // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
 
@@ skipping 57 matching lines @@
 #ifndef NDEBUG
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
         for (size_t j = 0; j < frame.renderPasses[i]->quad_list.size(); ++j)
             DCHECK(frame.renderPasses[i]->quad_list[j]->shared_quad_state);
         DCHECK(frame.renderPassesById.contains(frame.renderPasses[i]->id));
     }
 #endif
 
     if (!m_hasTransparentBackground) {
         frame.renderPasses.back()->has_transparent_background = false;
-        appendQuadsToFillScreen(frame.renderPasses.back(), m_rootLayerImpl.get(), m_backgroundColor, occlusionTracker);
+        appendQuadsToFillScreen(frame.renderPasses.back(), rootLayer(), m_backgroundColor, occlusionTracker);
     }
 
     if (drawFrame)
         occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
     m_renderer->decideRenderPassAllocationsForFrame(frame.renderPasses);
     removeRenderPasses(CullRenderPassesWithCachedTextures(*m_renderer), frame);
 
     return drawFrame;
@@ skipping 34 matching lines @@
     if (!m_timeSourceClientAdapter)
         m_timeSourceClientAdapter = LayerTreeHostImplTimeSourceAdapter::create(this, DelayBasedTimeSource::create(lowFrequencyAnimationInterval(), m_proxy->currentThread()));
 
     m_timeSourceClientAdapter->setActive(enabled);
 }
 
 gfx::Size LayerTreeHostImpl::contentSize() const
 {
     // TODO(aelias): Hardcoding the first child here is weird. Think of
     // a cleaner way to get the contentBounds on the Impl side.
-    if (!m_rootScrollLayerImpl || m_rootScrollLayerImpl->children().isEmpty())
+    if (!rootScrollLayer() || rootScrollLayer()->children().isEmpty())
         return gfx::Size();
-    return m_rootScrollLayerImpl->children()[0]->contentBounds();
+    return rootScrollLayer()->children()[0]->contentBounds();
 }
 
 static inline RenderPass* findRenderPassById(RenderPass::Id renderPassId, const LayerTreeHostImpl::FrameData& frame)
 {
     RenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
     DCHECK(it != frame.renderPassesById.end());
     return it->second;
 }
 
 static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, LayerTreeHostImpl::FrameData& frame)
@@ skipping 166 matching lines @@
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
     base::TimeTicks timebase = base::TimeTicks::FromInternalValue(monotonicTimebase * base::Time::kMicrosecondsPerSecond);
     base::TimeDelta interval = base::TimeDelta::FromMicroseconds(intervalInSeconds * base::Time::kMicrosecondsPerSecond);
     m_client->onVSyncParametersChanged(timebase, interval);
 }
 
+void LayerTreeHostImpl::OnCanDrawStateChangedForTree(LayerTreeImpl*)
+{
+  m_client->onCanDrawStateChanged(canDraw());
+}
+
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
     // RenderWidget.
     m_fpsCounter->markBeginningOfFrame(base::TimeTicks::Now());
 
     if (m_debugState.showHudRects())
-        m_debugRectHistory->saveDebugRectsForCurrentFrame(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_debugState);
+        m_debugRectHistory->saveDebugRectsForCurrentFrame(rootLayer(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_debugState);
 
     // Because the contents of the HUD depend on everything else in the frame, the contents
     // of its texture are updated as the last thing before the frame is drawn.
-    if (m_hudLayerImpl)
-        m_hudLayerImpl->updateHudTexture(m_resourceProvider.get());
+    if (m_activeTree->hud_layer())
+        m_activeTree->hud_layer()->updateHudTexture(m_resourceProvider.get());
 
     m_renderer->drawFrame(frame.renderPasses, frame.renderPassesById);
 
     // The render passes should be consumed by the renderer.
     DCHECK(frame.renderPasses.empty());
     DCHECK(frame.renderPassesById.empty());
 
     // The next frame should start by assuming nothing has changed, and changes are noted as they occur.
     for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)
         (*frame.renderSurfaceLayerList)[i]->renderSurface()->damageTracker()->didDrawDamagedArea();
-    m_rootLayerImpl->resetAllChangeTrackingForSubtree();
+    rootLayer()->resetAllChangeTrackingForSubtree();
 }
 
 void LayerTreeHostImpl::didDrawAllLayers(const FrameData& frame)
 {
     for (size_t i = 0; i < frame.willDrawLayers.size(); ++i)
         frame.willDrawLayers[i]->didDraw(m_resourceProvider.get());
 
     // Once all layers have been drawn, pending texture uploads should no
     // longer block future uploads.
     m_resourceProvider->markPendingUploadsAsNonBlocking();
@@ skipping 42 matching lines @@
 {
     m_client->onSwapBuffersCompleteOnImplThread();
 }
 
 void LayerTreeHostImpl::readback(void* pixels, const gfx::Rect& rect)
 {
     DCHECK(m_renderer);
     m_renderer->getFramebufferPixels(pixels, rect);
 }
 
-static LayerImpl* findRootScrollLayer(LayerImpl* layer)
-{
-    if (!layer)
-        return 0;
-
-    if (layer->scrollable())
-        return layer;
-
-    for (size_t i = 0; i < layer->children().size(); ++i) {
-        LayerImpl* found = findRootScrollLayer(layer->children()[i]);
-        if (found)
-            return found;
-    }
-
-    return 0;
-}
-
 // Content layers can be either directly scrollable or contained in an outer
 // scrolling layer which applies the scroll transform. Given a content layer,
 // this function returns the associated scroll layer if any.
 static LayerImpl* findScrollLayerForContentLayer(LayerImpl* layerImpl)
 {
     if (!layerImpl)
         return 0;
 
     if (layerImpl->scrollable())
         return layerImpl;
 
     if (layerImpl->drawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
         return layerImpl->parent();
 
     return 0;
 }
 
 void LayerTreeHostImpl::setRootLayer(scoped_ptr<LayerImpl> layer)
 {
-    m_rootLayerImpl = layer.Pass();
-    m_rootScrollLayerImpl = findRootScrollLayer(m_rootLayerImpl.get());
-    m_currentlyScrollingLayerImpl = 0;
-
-    if (m_rootLayerImpl && m_scrollingLayerIdFromPreviousTree != -1)
-        m_currentlyScrollingLayerImpl = LayerTreeHostCommon::findLayerInSubtree(m_rootLayerImpl.get(), m_scrollingLayerIdFromPreviousTree);
-
-    m_scrollingLayerIdFromPreviousTree = -1;
-
-    m_client->onCanDrawStateChanged(canDraw());
+  m_activeTree->SetRootLayer(layer.Pass());
 }
 
 scoped_ptr<LayerImpl> LayerTreeHostImpl::detachLayerTree()
 {
-    // Clear all data structures that have direct references to the layer tree.
-    m_scrollingLayerIdFromPreviousTree = m_currentlyScrollingLayerImpl ? m_currentlyScrollingLayerImpl->id() : -1;
-    m_currentlyScrollingLayerImpl = 0;
-    m_renderSurfaceLayerList.clear();
-
-    return m_rootLayerImpl.Pass();
+  scoped_ptr<LayerImpl> layer = m_activeTree->DetachLayerTree();
+  m_renderSurfaceLayerList.clear();
+  return layer.Pass();
 }
 
 void LayerTreeHostImpl::setVisible(bool visible)
 {
     DCHECK(m_proxy->isImplThread());
 
     if (m_visible == visible)
         return;
     m_visible = visible;
     didVisibilityChange(this, m_visible);
     enforceManagedMemoryPolicy(m_managedMemoryPolicy);
 
     if (!m_renderer)
         return;
 
     m_renderer->setVisible(visible);
 
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
 bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
 {
     // 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 (m_rootLayerImpl) {
+    if (rootLayer()) {
         clearRenderSurfaces();
-        sendDidLoseOutputSurfaceRecursive(m_rootLayerImpl.get());
+        sendDidLoseOutputSurfaceRecursive(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 86 matching lines @@
 void LayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
     if (!pageScaleFactor)
       return;
 
     float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFactor();
     m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
 
     if (!m_settings.pageScalePinchZoomEnabled) {
         if (pageScaleChange != 1)
-            adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+            adjustScrollsForPageScaleChange(rootScrollLayer(), pageScaleChange);
     }
 
     // Clamp delta to limits and refresh display matrix.
     setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport.sentPageScaleDelta());
     m_pinchZoomViewport.setSentPageScaleDelta(1);
 }
 
 void LayerTreeHostImpl::setPageScaleDelta(float delta)
 {
     m_pinchZoomViewport.setPageScaleDelta(delta);
 
     updateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::updateMaxScrollOffset()
 {
-    if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
+    if (!rootScrollLayer() || !rootScrollLayer()->children().size())
         return;
 
     gfx::SizeF viewBounds = m_deviceViewportSize;
-    if (LayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
+    if (LayerImpl* clipLayer = rootScrollLayer()->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds())
             viewBounds = gfx::ScaleSize(clipLayer->bounds(), m_deviceScaleFactor);
     }
 
     gfx::Size contentBounds = contentSize();
     if (m_settings.pageScalePinchZoomEnabled) {
         // Pinch with pageScale scrolls entirely in layout space.  contentSize
         // returns the bounds including the page scale factor, so calculate the
         // pre page-scale layout size here.
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         contentBounds.set_width(contentBounds.width() / pageScaleFactor);
         contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
         viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
     gfx::Vector2dF maxScroll = gfx::Rect(contentBounds).bottom_right() - gfx::RectF(viewBounds).bottom_right();
     maxScroll.Scale(1 / m_deviceScaleFactor);
 
     // The viewport may be larger than the contents in some cases, such as
     // having a vertical scrollbar but no horizontal overflow.
     maxScroll.ClampToMin(gfx::Vector2dF());
 
-    m_rootScrollLayerImpl->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));
+    rootScrollLayer()->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));
 }
 
 void LayerTreeHostImpl::setNeedsRedraw()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
 bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
 {
-    if (!m_rootLayerImpl)
+    if (!rootLayer())
         return false;
     if (!m_renderer)
         return false;
 
     // We need both a non-empty render surface layer list and a root render
     // surface to be able to iterate over the visible layers.
-    if (m_renderSurfaceLayerList.size() && m_rootLayerImpl->renderSurface())
+    if (m_renderSurfaceLayerList.size() && rootLayer()->renderSurface())
         return true;
 
     // If we are called after setRootLayer() but before prepareToDraw(), we need
     // to recalculate the visible layers. This prevents being unable to scroll
     // during part of a commit.
     m_renderSurfaceLayerList.clear();
     calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
 
     return m_renderSurfaceLayerList.size();
 }
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
-    DCHECK(!m_currentlyScrollingLayerImpl);
+    DCHECK(!currentlyScrollingLayer());
     clearCurrentlyScrollingLayer();
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
     gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, m_renderSurfaceLayerList);
@@ skipping 17 matching lines @@
         if (status == ScrollOnMainThread) {
             m_numMainThreadScrolls++;
             return ScrollOnMainThread;
         }
 
         if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     if (potentiallyScrollingLayerImpl) {
-        m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
+        m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
         // Gesture events need to be transformed from viewport coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInViewportSpace = (type == Gesture);
         m_numImplThreadScrolls++;
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
@@ skipping 53 matching lines @@
 {
     gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
 bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
                                  const gfx::Vector2d& scrollDelta)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
-    if (!m_currentlyScrollingLayerImpl)
+    if (!currentlyScrollingLayer())
         return false;
 
     gfx::Vector2dF pendingDelta = scrollDelta;
     bool didScroll = false;
 
-    for (LayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; layerImpl = layerImpl->parent()) {
+    for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
         if (!layerImpl->scrollable())
             continue;
 
         PinchZoomViewport* viewport = NULL;
-        if (m_settings.pageScalePinchZoomEnabled && layerImpl == m_rootScrollLayerImpl)
+        if (m_settings.pageScalePinchZoomEnabled && layerImpl == rootScrollLayer())
             viewport = &m_pinchZoomViewport;
         gfx::Vector2dF appliedDelta;
         if (m_scrollDeltaIsInViewportSpace) {
             float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
             appliedDelta = scrollLayerWithViewportSpaceDelta(viewport, *layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
         } else
             appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
 
         // If the layer wasn't able to move, try the next one in the hierarchy.
         float moveThresholdSquared = 0.1f * 0.1f;
@@ skipping 20 matching lines @@
 
     if (didScroll) {
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
     }
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
-    m_currentlyScrollingLayerImpl = 0;
-    m_scrollingLayerIdFromPreviousTree = -1;
+    m_activeTree->ClearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::scrollEnd()
 {
     clearCurrentlyScrollingLayer();
 }
 
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = gfx::Point();
 
-    if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
-        m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureBegin();
+    if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
+        rootScrollLayer()->scrollbarAnimationController()->didPinchGestureBegin();
 }
 
 void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");
 
-    if (!m_rootScrollLayerImpl)
+    if (!rootScrollLayer())
         return;
 
     // Keep the center-of-pinch anchor specified by (x, y) in a stable
     // position over the course of the magnify.
     float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     gfx::PointF previousScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
     setPageScaleDelta(pageScaleDelta * magnifyDelta);
     pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     gfx::PointF newScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
     gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
     if (m_settings.pageScalePinchZoomEnabled) {
         // Compute the application of the delta with respect to the current page zoom of the page.
         move.Scale(1 / m_pinchZoomViewport.pageScaleFactor());
     }
 
     gfx::Vector2dF scrollOverflow = m_settings.pageScalePinchZoomEnabled ? m_pinchZoomViewport.applyScroll(move) : move;
-    m_rootScrollLayerImpl->scrollBy(scrollOverflow);
+    rootScrollLayer()->scrollBy(scrollOverflow);
 
-    if (m_rootScrollLayerImpl->scrollbarAnimationController())
-        m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
+    if (rootScrollLayer()->scrollbarAnimationController())
+        rootScrollLayer()->scrollbarAnimationController()->didPinchGestureUpdate();
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
-    if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
-        m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEnd();
+    if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
+        rootScrollLayer()->scrollbarAnimationController()->didPinchGestureEnd();
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
     gfx::Vector2dF scaledScrollOffset = m_pageScaleAnimation->targetScrollOffset();
     if (!m_settings.pageScalePinchZoomEnabled)
         scaledScrollOffset.Scale(m_pinchZoomViewport.pageScaleFactor());
     makeScrollAndScaleSet(scrollInfo, ToFlooredVector2d(scaledScrollOffset), m_pageScaleAnimation->targetPageScaleFactor());
 }
 
 void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
-    if (!m_rootScrollLayerImpl)
+    if (!rootScrollLayer())
         return;
 
     // Only send fake scroll/zoom deltas if we're pinch zooming out by a
     // significant amount. This also ensures only one fake delta set will be
     // sent.
     const float pinchZoomOutSensitivity = 0.95f;
     if (m_pinchZoomViewport.pageScaleDelta() > pinchZoomOutSensitivity)
         return;
 
     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
     // out from the anchor point.
-    gfx::Vector2dF scrollBegin = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
+    gfx::Vector2dF scrollBegin = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     scrollBegin.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
     float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
     gfx::SizeF scaledContentsSize = gfx::ScaleSize(contentSize(), pageScaleDeltaToSend);
 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
     scrollEnd.Scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
     scrollEnd -= anchorOffset;
     scrollEnd.ClampToMax(gfx::RectF(scaledContentsSize).bottom_right() - gfx::Rect(m_deviceViewportSize).bottom_right());
     scrollEnd.ClampToMin(gfx::Vector2d());
     scrollEnd.Scale(1 / pageScaleDeltaToSend);
     scrollEnd.Scale(m_deviceScaleFactor);
 
     makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());
 }
 
 void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)
 {
-    if (!m_rootScrollLayerImpl)
+    if (!rootScrollLayer())
         return;
 
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
-    scroll.layerId = m_rootScrollLayerImpl->id();
-    scroll.scrollDelta = scrollOffset - m_rootScrollLayerImpl->scrollOffset();
+    scroll.layerId = rootScrollLayer()->id();
+    scroll.scrollDelta = scrollOffset - rootScrollLayer()->scrollOffset();
     scrollInfo->scrolls.push_back(scroll);
-    m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta);
+    rootScrollLayer()->setSentScrollDelta(scroll.scrollDelta);
     scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.pageScaleFactor();
     m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 }
 
 static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
 {
     if (!layerImpl)
         return;
 
     if (!layerImpl->scrollDelta().IsZero()) {
@@ skipping 18 matching lines @@
         m_pinchZoomViewport.setSentPageScaleDelta(1);
         // FIXME(aelias): Make pinch-zoom painting optimization compatible with
         // compositor-side scaling.
         if (!m_settings.pageScalePinchZoomEnabled && m_pinchGestureActive)
             computePinchZoomDeltas(scrollInfo.get());
         else if (m_pageScaleAnimation.get())
             computeDoubleTapZoomDeltas(scrollInfo.get());
         return scrollInfo.Pass();
     }
 
-    collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get());
+    collectScrollDeltas(scrollInfo.get(), rootLayer());
     scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
     m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.Pass();
 }
 
 gfx::Transform LayerTreeHostImpl::implTransform() const
 {
     return m_pinchZoomViewport.implTransform(m_settings.pageScalePinchZoomEnabled);
 }
 
 void LayerTreeHostImpl::setFullRootLayerDamage()
 {
-    if (m_rootLayerImpl) {
-        RenderSurfaceImpl* renderSurface = m_rootLayerImpl->renderSurface();
+    if (rootLayer()) {
+        RenderSurfaceImpl* renderSurface = rootLayer()->renderSurface();
         if (renderSurface)
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
     }
 }
 
 void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
-    if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
+    if (!m_pageScaleAnimation || !rootScrollLayer())
         return;
 
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
-    gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
+    gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
 
     setPageScaleDelta(m_pageScaleAnimation->pageScaleFactorAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
     gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
 
     if (!m_settings.pageScalePinchZoomEnabled)
         nextScroll.Scale(m_pinchZoomViewport.pageScaleFactor());
-    m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
+    rootScrollLayer()->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
-    if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers || !m_rootLayerImpl)
+    if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers || !rootLayer())
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
 
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
 
     bool didAnimate = false;
-    animateLayersRecursive(m_rootLayerImpl.get(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
+    animateLayersRecursive(rootLayer(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
 
     if (!events->empty())
         m_client->postAnimationEventsToMainThreadOnImplThread(events.Pass(), wallClockTime);
 
     if (didAnimate)
         m_client->setNeedsRedrawOnImplThread();
 
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
@@ skipping 17 matching lines @@
 static void clearRenderSurfacesOnLayerImplRecursive(LayerImpl* current)
 {
     DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
         clearRenderSurfacesOnLayerImplRecursive(current->children()[i]);
     current->clearRenderSurface();
 }
 
 void LayerTreeHostImpl::clearRenderSurfaces()
 {
-    clearRenderSurfacesOnLayerImplRecursive(m_rootLayerImpl.get());
+    clearRenderSurfacesOnLayerImplRecursive(rootLayer());
     m_renderSurfaceLayerList.clear();
 }
 
 std::string LayerTreeHostImpl::layerTreeAsText() const
 {
     std::string str;
-    if (m_rootLayerImpl) {
-        str = m_rootLayerImpl->layerTreeAsText();
+    if (rootLayer()) {
+        str = rootLayer()->layerTreeAsText();
         str +=  "RenderSurfaces:\n";
-        dumpRenderSurfaces(&str, 1, m_rootLayerImpl.get());
+        dumpRenderSurfaces(&str, 1, rootLayer());
     }
     return str;
 }
 
 void LayerTreeHostImpl::dumpRenderSurfaces(std::string* str, int indent, const LayerImpl* layer) const
 {
     if (layer->renderSurface())
         layer->renderSurface()->dumpSurface(str, indent);
 
     for (size_t i = 0; i < layer->children().size(); ++i)
@@ skipping 12 matching lines @@
     stats->numImplThreadScrolls = m_numImplThreadScrolls;
     stats->numMainThreadScrolls = m_numMainThreadScrolls;
     stats->numLayersDrawn = m_cumulativeNumLayersDrawn;
 
     if (m_tileManager)
         m_tileManager->renderingStats(stats);
 }
 
 void LayerTreeHostImpl::animateScrollbars(base::TimeTicks time)
 {
-    animateScrollbarsRecursive(m_rootLayerImpl.get(), time);
+    animateScrollbarsRecursive(rootLayer(), time);
 }
 
 void LayerTreeHostImpl::animateScrollbarsRecursive(LayerImpl* layer, base::TimeTicks time)
 {
     if (!layer)
         return;
 
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc