Make new-style page scale work on Android.

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 236 matching lines @@
                            memoryNiceToHaveBytes,
                            memoryUsedBytes);
 }
 
 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 scaledContentSize = contentSize();
+    gfx::SizeF scaledContentSize = activeTree()->ScrollableSize();

[danakj, 2013/01/17 18:02:49]

rename scaledContentSize to what it now holds as well please

[aelias_OOO_until_Jul13, 2013/01/17 19:59:46]

Done.

[aelias_OOO_until_Jul13, 2013/01/17 19:59:46]

Done.

     if (!m_settings.pageScalePinchZoomEnabled) {
         scrollTotal.Scale(1 / m_pinchZoomViewport.page_scale_factor());
         scaledContentSize.Scale(1 / m_pinchZoomViewport.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, scaledContentSize, startTimeSeconds);

[danakj, 2013/01/17 18:02:49]

Without a change to PageScaleAnimation how does this continue to work? You're
passing in the logical scroll size now instead of the physical scroll size,
right?

[aelias_OOO_until_Jul13, 2013/01/17 19:59:46]

This function was already prepared for the coordinate space transition by an
earlier patch of mine.  A few lines above, notice I divide scroll by
page_scale_factor if the setting is disabled.

 
     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 271 matching lines @@
 
 void LayerTreeHostImpl::setBackgroundTickingEnabled(bool enabled)
 {
     // Lazily create the timeSource adapter so that we can vary the interval for testing.
     if (!m_timeSourceClientAdapter)
         m_timeSourceClientAdapter = LayerTreeHostImplTimeSourceAdapter::create(this, DelayBasedTimeSource::create(lowFrequencyAnimationInterval(), m_proxy->currentThread()));
 
     m_timeSourceClientAdapter->setActive(enabled);
 }
 
-gfx::Size LayerTreeHostImpl::contentSize() const
-{
-    return activeTree()->ContentSize();
-}
-
 static inline RenderPass* findRenderPassById(RenderPass::Id renderPassId, const LayerTreeHostImpl::FrameData& frame)
 {
     RenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
     return it != frame.renderPassesById.end() ? it->second : NULL;
 }
 
 static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, LayerTreeHostImpl::FrameData& frame)
 {
     RenderPass* removeRenderPass = findRenderPassById(removeRenderPassId, frame);
     // The pass was already removed by another quad - probably the original, and we are the replica.
@@ skipping 189 matching lines @@
 CompositorFrameMetadata LayerTreeHostImpl::makeCompositorFrameMetadata() const
 {
     if (!rootScrollLayer())
         return CompositorFrameMetadata();
 
     CompositorFrameMetadata 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.page_scale_factor = m_pinchZoomViewport.total_page_scale_factor();
-    metadata.viewport_size = m_pinchZoomViewport.Bounds().size();
-    metadata.root_layer_size = contentSize();
+    metadata.viewport_size = m_pinchZoomViewport.ZoomedViewport().size();
+    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();
 
     return metadata;
 }
 
 void LayerTreeHostImpl::drawLayers(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
@@ skipping 238 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)
@@ skipping 323 matching lines @@
     const float pinchZoomOutSensitivity = 0.95f;
     if (m_pinchZoomViewport.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();
-    gfx::SizeF scaledContentsSize = gfx::ScaleSize(contentSize(), pageScaleDeltaToSend);
+    gfx::SizeF scaledContentsSize = gfx::ScaleSize(activeTree()->ScrollableSize(), pageScaleDeltaToSend);

[danakj, 2013/01/17 18:02:49]

rename scaledContentsSize here also

[aelias_OOO_until_Jul13, 2013/01/17 19:59:46]

Done.

 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
     scrollEnd.Scale(m_pinchZoomViewport.min_page_scale_factor() / scaleBegin);
     scrollEnd -= anchorOffset;
     scrollEnd.ClampToMax(gfx::RectF(scaledContentsSize).bottom_right() - gfx::Rect(m_deviceViewportSize).bottom_right());

[danakj, 2013/01/17 18:02:49]

You mentioned that scrolling should all be in logical pixels now, so
scaledContentsSize should be the logical scroll size (ie not content/phsyical
pixels)?. So, should we be subtracting the logical viewport size here then?

[aelias_OOO_until_Jul13, 2013/01/17 19:59:46]

This method adjustScrollsForPageScaleChange is purely for the old coordinate
space world, so it doesn't need a change.

     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())
@@ skipping 248 matching lines @@
 }
 
 skia::RefPtr<SkPicture> LayerTreeHostImpl::capturePicture()
 {
     LayerTreeImpl* tree = pendingTree() ? pendingTree() : activeTree();
     LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
     return layer ? layer->getPicture() : skia::RefPtr<SkPicture>();
 }
 
 }  // namespace cc