Move page scale ownership 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 247 matching lines @@
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
     if (!rootScrollLayer())
         return;
 
     gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     gfx::SizeF scaledScrollableSize = activeTree()->ScrollableSize();
     if (!m_settings.pageScalePinchZoomEnabled) {
-        scrollTotal.Scale(1 / m_pinchZoomViewport.page_scale_factor());
-        scaledScrollableSize.Scale(1 / m_pinchZoomViewport.page_scale_factor());
+        scrollTotal.Scale(1 / activeTree()->page_scale_factor());
+        scaledScrollableSize.Scale(1 / activeTree()->page_scale_factor());
     }
     gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
-    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, m_pinchZoomViewport.total_page_scale_factor(), viewportSize, scaledScrollableSize, startTimeSeconds);
+    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, activeTree()->total_page_scale_factor(), viewportSize, scaledScrollableSize, startTimeSeconds);
 
     if (anchorPoint) {
         gfx::Vector2dF anchor(targetOffset);
         if (!m_settings.pageScalePinchZoomEnabled)
             anchor.Scale(1 / pageScale);
         m_pageScaleAnimation->zoomWithAnchor(anchor, pageScale, duration.InSecondsF());
     } else {
         gfx::Vector2dF scaledTargetOffset = targetOffset;
         if (!m_settings.pageScalePinchZoomEnabled)
             scaledTargetOffset.Scale(1 / pageScale);
@@ skipping 462 matching lines @@
 }
 
 void LayerTreeHostImpl::OnCanDrawStateChangedForTree(LayerTreeImpl*)
 {
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 CompositorFrameMetadata LayerTreeHostImpl::makeCompositorFrameMetadata() const
 {
     CompositorFrameMetadata metadata;
-    metadata.page_scale_factor = m_pinchZoomViewport.total_page_scale_factor();
+    metadata.page_scale_factor = activeTree()->total_page_scale_factor();
     metadata.viewport_size = activeTree()->ScrollableViewportSize();
     metadata.root_layer_size = activeTree()->ScrollableSize();
-    metadata.min_page_scale_factor = m_pinchZoomViewport.min_page_scale_factor();
-    metadata.max_page_scale_factor = m_pinchZoomViewport.max_page_scale_factor();
+    metadata.min_page_scale_factor = activeTree()->min_page_scale_factor();
+    metadata.max_page_scale_factor = activeTree()->max_page_scale_factor();
     if (m_topControlsManager) {
         metadata.location_bar_offset = gfx::Vector2dF(0.f, m_topControlsManager->controls_top_offset());
         metadata.location_bar_content_translation = gfx::Vector2dF(0.f, m_topControlsManager->content_top_offset());
     }
 
     if (!rootScrollLayer())
       return metadata;
 
     metadata.root_scroll_offset = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
     if (!m_settings.pageScalePinchZoomEnabled)
-        metadata.root_scroll_offset.Scale(1 / m_pinchZoomViewport.page_scale_factor());
+        metadata.root_scroll_offset.Scale(1 / activeTree()->page_scale_factor());
 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
@@ skipping 194 matching lines @@
 void LayerTreeHostImpl::activatePendingTree()
 {
     CHECK(m_pendingTree);
     TRACE_EVENT_ASYNC_END0("cc", "PendingTree", m_pendingTree.get());
 
     m_activeTree->PushPersistedState(m_pendingTree.get());
     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();
-    if (m_pendingTree->hud_layer())
-        m_activeTree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(LayerTreeHostCommon::findLayerInSubtree(m_activeTree->RootLayer(), m_pendingTree->hud_layer()->id())));
-    else
-        m_activeTree->set_hud_layer(NULL);
+    m_pendingTree->pushPropertiesTo(m_activeTree.get());
 
     // 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());
@@ skipping 77 matching lines @@
 }
 
 void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
-    m_pinchZoomViewport.set_layout_viewport_size(layoutViewportSize);
-    m_pinchZoomViewport.set_device_viewport_size(deviceViewportSize);
-
     updateMaxScrollOffset();
 
     if (m_renderer)
         m_renderer->viewportChanged();
 
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
 {
     if (!layerImpl)
         return;
 
     if (layerImpl->scrollable()) {
         // We need to convert impl-side scroll deltas to pageScale space.
         gfx::Vector2dF scrollDelta = layerImpl->scrollDelta();
         scrollDelta.Scale(pageScaleChange);
         layerImpl->setScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
 }
 
 void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor == m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
-    m_pinchZoomViewport.set_device_scale_factor(m_deviceScaleFactor);
 
     updateMaxScrollOffset();
 }
 
-float LayerTreeHostImpl::pageScaleFactor() const
-{
-    return m_pinchZoomViewport.page_scale_factor();
-}
-
-void LayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
-{
-    if (!pageScaleFactor)
-      return;
-
-    float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.page_scale_factor();
-    m_pinchZoomViewport.SetPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
-
-    if (!m_settings.pageScalePinchZoomEnabled && pageScaleChange != 1)
-        adjustScrollsForPageScaleChange(rootScrollLayer(), pageScaleChange);
-
-    // Clamp delta to limits and refresh display matrix.
-    setPageScaleDelta(m_pinchZoomViewport.page_scale_delta() / m_pinchZoomViewport.sent_page_scale_delta());
-    m_pinchZoomViewport.set_sent_page_scale_delta(1);
-}
-
-void LayerTreeHostImpl::setPageScaleDelta(float delta)
-{
-    if (m_pinchZoomViewport.page_scale_delta() == delta)
-        return;
-
-    m_pinchZoomViewport.set_page_scale_delta(delta);
-
-    updateMaxScrollOffset();
-    activeTree()->set_needs_update_draw_properties();
-    if (pendingTree())
-        pendingTree()->set_needs_update_draw_properties();
-}
-
 void LayerTreeHostImpl::updateMaxScrollOffset()
 {
     activeTree()->UpdateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::setActiveTreeNeedsUpdateDrawProperties()
 {
     activeTree()->set_needs_update_draw_properties();
 }
 
@@ skipping 200 matching lines @@
 
 void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");
 
     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.page_scale_delta();
+    float pageScaleDelta = activeTree()->page_scale_delta();
     gfx::PointF previousScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
-    setPageScaleDelta(pageScaleDelta * magnifyDelta);
-    pageScaleDelta = m_pinchZoomViewport.page_scale_delta();
+    activeTree()->SetPageScaleDelta(pageScaleDelta * magnifyDelta);
+    pageScaleDelta = activeTree()->page_scale_delta();
     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.page_scale_factor());
-    }
+    if (m_settings.pageScalePinchZoomEnabled)
+        move.Scale(1 / activeTree()->page_scale_factor());
 
     rootScrollLayer()->scrollBy(move);
 
     if (rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureUpdate(base::TimeTicks::Now());
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
     m_client->renewTreePriority();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
     if (rootScrollLayer() && rootScrollLayer()->scrollbarAnimationController())
         rootScrollLayer()->scrollbarAnimationController()->didPinchGestureEnd(base::TimeTicks::Now());
 
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::computeDoubleTapZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
     gfx::Vector2dF scaledScrollOffset = m_pageScaleAnimation->targetScrollOffset();
     if (!m_settings.pageScalePinchZoomEnabled)
-        scaledScrollOffset.Scale(m_pinchZoomViewport.page_scale_factor());
+        scaledScrollOffset.Scale(activeTree()->page_scale_factor());
     makeScrollAndScaleSet(scrollInfo, ToFlooredVector2d(scaledScrollOffset), m_pageScaleAnimation->targetPageScaleFactor());
 }
 
 void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
 {
     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.page_scale_delta() > pinchZoomOutSensitivity)
+    if (activeTree()->page_scale_delta() > pinchZoomOutSensitivity)
         return;
 
     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
     // out from the anchor point.
     gfx::Vector2dF scrollBegin = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
-    scrollBegin.Scale(m_pinchZoomViewport.page_scale_delta());
-    float scaleBegin = m_pinchZoomViewport.total_page_scale_factor();
-    float pageScaleDeltaToSend = m_pinchZoomViewport.min_page_scale_factor() / m_pinchZoomViewport.page_scale_factor();
+    scrollBegin.Scale(activeTree()->page_scale_delta());
+    float scaleBegin = activeTree()->total_page_scale_factor();
+    float pageScaleDeltaToSend = activeTree()->min_page_scale_factor() / activeTree()->page_scale_factor();
     gfx::SizeF scaledScrollableSize = gfx::ScaleSize(activeTree()->ScrollableSize(), pageScaleDeltaToSend);
 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
-    scrollEnd.Scale(m_pinchZoomViewport.min_page_scale_factor() / scaleBegin);
+    scrollEnd.Scale(activeTree()->min_page_scale_factor() / scaleBegin);
     scrollEnd -= anchorOffset;
     scrollEnd.ClampToMax(gfx::RectF(scaledScrollableSize).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.min_page_scale_factor());
-}
-
-void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)
-{
-    if (!rootScrollLayer())
-        return;
-
-    LayerTreeHostCommon::ScrollUpdateInfo scroll;
-    scroll.layerId = rootScrollLayer()->id();
-    scroll.scrollDelta = scrollOffset - rootScrollLayer()->scrollOffset();
-    scrollInfo->scrolls.push_back(scroll);
-    activeTree()->RootScrollLayer()->setSentScrollDelta(scroll.scrollDelta);
-    scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.page_scale_factor();
-    m_pinchZoomViewport.set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
+    makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), activeTree()->min_page_scale_factor());
 }
 
 static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
 {
     if (!layerImpl)
         return;
 
     gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scrollDelta());
     if (!scrollDelta.IsZero()) {
         LayerTreeHostCommon::ScrollUpdateInfo scroll;
         scroll.layerId = layerImpl->id();
         scroll.scrollDelta = scrollDelta;
         scrollInfo->scrolls.push_back(scroll);
         layerImpl->setSentScrollDelta(scrollDelta);
     }
 
     for (size_t i = 0; i < layerImpl->children().size(); ++i)
         collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
 }
 
+void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)
+{
+    if (!rootScrollLayer())
+        return;
+
+    LayerTreeHostCommon::ScrollUpdateInfo scroll;
+    scroll.layerId = rootScrollLayer()->id();
+    scroll.scrollDelta = scrollOffset - rootScrollLayer()->scrollOffset();
+    scrollInfo->scrolls.push_back(scroll);
+    activeTree()->RootScrollLayer()->setSentScrollDelta(scroll.scrollDelta);
+    scrollInfo->pageScaleDelta = pageScale / activeTree()->page_scale_factor();
+    activeTree()->set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
+}
+
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
 {
     scoped_ptr<ScrollAndScaleSet> scrollInfo(new ScrollAndScaleSet());
 
     if (!m_settings.pageScalePinchZoomEnabled && (m_pinchGestureActive || m_pageScaleAnimation)) {
         scrollInfo->pageScaleDelta = 1;
-        m_pinchZoomViewport.set_sent_page_scale_delta(1);
+        activeTree()->set_sent_page_scale_delta(1);
         if (m_pinchGestureActive)
             computePinchZoomDeltas(scrollInfo.get());
         else if (m_pageScaleAnimation.get())
             computeDoubleTapZoomDeltas(scrollInfo.get());
         return scrollInfo.Pass();
     }
 
     collectScrollDeltas(scrollInfo.get(), rootLayer());
-    scrollInfo->pageScaleDelta = m_pinchZoomViewport.page_scale_delta();
-    m_pinchZoomViewport.set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
+    scrollInfo->pageScaleDelta = activeTree()->page_scale_delta();
+    activeTree()->set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
 
     return scrollInfo.Pass();
 }
 
-gfx::Transform LayerTreeHostImpl::implTransform() const
-{
-    return m_pinchZoomViewport.ImplTransform(m_settings.pageScalePinchZoomEnabled);
-}
-
 void LayerTreeHostImpl::setFullRootLayerDamage()
 {
     if (rootLayer()) {
         RenderSurfaceImpl* renderSurface = rootLayer()->renderSurface();
         if (renderSurface)
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
     }
 }
 
 void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
     if (!m_pageScaleAnimation || !rootScrollLayer())
         return;
 
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     gfx::Vector2dF scrollTotal = rootScrollLayer()->scrollOffset() + rootScrollLayer()->scrollDelta();
 
-    setPageScaleDelta(m_pageScaleAnimation->pageScaleFactorAtTime(monotonicTime) / m_pinchZoomViewport.page_scale_factor());
+    activeTree()->SetPageScaleDelta(m_pageScaleAnimation->pageScaleFactorAtTime(monotonicTime) / activeTree()->page_scale_factor());
     gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
 
     if (!m_settings.pageScalePinchZoomEnabled)
-        nextScroll.Scale(m_pinchZoomViewport.page_scale_factor());
+        nextScroll.Scale(activeTree()->page_scale_factor());
     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)
@@ skipping 186 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