Move page scale ownership to LayerTreeImpl.

cc/layer_tree_host_impl.cc

Index: cc/layer_tree_host_impl.cc
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 364883b5a2605f80977ea1a01fe6413e8909fe44..45a00508e7a90849e25e6a722aeaa858e4009128 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -264,13 +264,13 @@ void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool
     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);
@@ -753,11 +753,11 @@ void LayerTreeHostImpl::OnCanDrawStateChangedForTree(LayerTreeImpl*)
 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());
@@ -768,7 +768,7 @@ CompositorFrameMetadata LayerTreeHostImpl::makeCompositorFrameMetadata() const
 
     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;
 }
@@ -954,6 +954,15 @@ void LayerTreeHostImpl::activatePendingTree()
     TreeSynchronizer::pushProperties(m_pendingTree->RootLayer(), m_activeTree->RootLayer());
     DCHECK(!m_recycleTree);
 
+    m_activeTree->SetPageScaleFactorAndLimits(m_pendingTree->page_scale_factor(), m_pendingTree->min_page_scale_factor(), m_pendingTree->max_page_scale_factor());

[enne (OOO), 2013/01/28 21:03:46]

Can you make a LayerTreeImpl -> LayerTreeImpl pushPropertiesTo function and move
all this there?

[aelias_OOO_until_Jul13, 2013/01/29 06:05:14]

Done.

+    m_activeTree->SetPageScaleDelta(m_activeTree->page_scale_delta() / m_activeTree->sent_page_scale_delta());
+    m_activeTree->set_sent_page_scale_delta(1);
+
+#if 0
+    layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
+    layer->setSentScrollDelta(gfx::Vector2d());
+#endif
+
     // This should match the property synchronization in
     // LayerTreeHost::finishCommitOnImplThread().
     m_activeTree->set_source_frame_number(m_pendingTree->source_frame_number());
@@ -1064,9 +1073,6 @@ void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, con
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
-    m_pinchZoomViewport.set_layout_viewport_size(layoutViewportSize);
-    m_pinchZoomViewport.set_device_viewport_size(deviceViewportSize);
-
     updateMaxScrollOffset();
 
     if (m_renderer)
@@ -1096,43 +1102,8 @@ 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()
@@ -1355,19 +1326,17 @@ void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor
 
     // 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);
 
@@ -1389,11 +1358,29 @@ void LayerTreeHostImpl::pinchGestureEnd()
     m_client->setNeedsCommitOnImplThread();
 }
 
+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::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());
 }
 
@@ -1406,27 +1393,27 @@ void LayerTreeHostImpl::computePinchZoomDeltas(ScrollAndScaleSet* scrollInfo)
     // 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());
+    makeScrollAndScaleSet(scrollInfo, gfx::ToRoundedVector2d(scrollEnd), activeTree()->min_page_scale_factor());
 }
 
 void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx::Vector2d scrollOffset, float pageScale)
@@ -1439,26 +1426,8 @@ void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, gfx
     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);
-}
-
-static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)

[danakj, 2013/01/28 20:29:03]

didn't need to move this function did you?

[aelias_OOO_until_Jul13, 2013/01/29 06:05:14]

Done.

-{
-    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]);
+    scrollInfo->pageScaleDelta = pageScale / activeTree()->page_scale_factor();
+    activeTree()->set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
 }
 
 scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
@@ -1467,7 +1436,7 @@ scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
 
     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())
@@ -1476,17 +1445,12 @@ scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
     }
 
     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()) {
@@ -1504,11 +1468,11 @@ void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
     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();