Add latency measurement system

cc/layer_tree_host_impl_unittest.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 <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 82 matching lines @@
     virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
     virtual void onVSyncParametersChanged(base::TimeTicks, base::TimeDelta) OVERRIDE { }
     virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
     virtual void onHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE { m_hasPendingTree = hasPendingTree; }
     virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
     virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
     virtual void setNeedsManageTilesOnImplThread() OVERRIDE { }
     virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
     virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
     virtual void sendManagedMemoryStats() OVERRIDE { }
+    virtual void onReceivedLatencyInfo(const LatencyInfo& latencyInfo) OVERRIDE { }
 
     void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
 
     void createLayerTreeHost(bool partialSwap, scoped_ptr<OutputSurface> outputSurface)
     {
         LayerTreeSettings settings;
         settings.minimumOcclusionTrackingSize = gfx::Size();
         settings.partialSwapEnabled = partialSwap;
 
         m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
@@ skipping 244 matching lines @@
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta + scrollDelta2);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollWithoutRootLayer)
 {
     // We should not crash when trying to scroll an empty layer tree.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
 }
@@ skipping 22 matching lines @@
     initializeRendererAndDrawFrame();
 
     // We should not crash if the tree is replaced while we are scrolling.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
     m_hostImpl->detachLayerTree();
 
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
     gfx::Vector2d scrollDelta(0, 10);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
 
 TEST_P(LayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
     m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
     initializeRendererAndDrawFrame();
@@ skipping 45 matching lines @@
     root->setNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
 
     initializeRendererAndDrawFrame();
 
     // All scroll types inside the non-fast scrollable region should fail.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
 
     // All scroll types outside this region should succeed.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
 }
 
 TEST_P(LayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
 {
     setupScrollAndContentsLayers(gfx::Size(200, 200));
     m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     LayerImpl* root = m_hostImpl->rootLayer();
     root->setContentsScale(2, 2);
     root->setNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
     root->setPosition(gfx::PointF(-25, 0));
 
     initializeRendererAndDrawFrame();
 
     // This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(40, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 1));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 1));
     m_hostImpl->scrollEnd();
 
     // This point is still inside the non-fast region.
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollByReturnsCorrectValue)
 {
     setupScrollAndContentsLayers(gfx::Size(200, 200));
     m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(InputHandlerClient::ScrollStarted,
         m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
 
     // Trying to scroll to the left/top will not succeed.
-    EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
-    EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
-    EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
+    EXPECT_FALSE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, 0)));
+    EXPECT_FALSE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, -10)));
+    EXPECT_FALSE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, -10)));
 
     // Scrolling to the right/bottom will succeed.
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, 0)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, 10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(10, 0)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(10, 10)));
 
     // Scrolling to left/top will now succeed.
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, 0)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, -10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, -10)));
 
     // Scrolling diagonally against an edge will succeed.
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, -10)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(10, -10)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, 0)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(-10, 10)));
 
     // Trying to scroll more than the available space will also succeed.
-    EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(5000, 5000)));
+    EXPECT_TRUE(m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(5000, 5000)));
 }
 
 TEST_P(LayerTreeHostImplTest, maxScrollOffsetChangedByDeviceScaleFactor)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
 
     float deviceScaleFactor = 2;
     gfx::Size layoutViewport(25, 25);
     gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(layoutViewport, deviceScaleFactor)));
     m_hostImpl->setViewportSize(layoutViewport, deviceViewport);
@@ skipping 48 matching lines @@
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(gfx::Vector2d());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
         m_hostImpl->pinchGestureEnd();
 
         gfx::Vector2d scrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-        m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+        m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, pinchGesture)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
@@ skipping 84 matching lines @@
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(gfx::Vector2d());
         scrollLayer->setScrollOffset(gfx::Vector2d(20, 20));
 
         float pageScaleDelta = 1;
         m_hostImpl->scrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel);
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
-        m_hostImpl->scrollBy(gfx::Point(10, 10), gfx::Vector2d(-10, -10));
+        m_hostImpl->scrollBy(0, gfx::Point(10, 10), gfx::Vector2d(-10, -10));
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
         m_hostImpl->pinchGestureEnd();
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
         expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-10, -10));
     }
 }
 
@@ skipping 146 matching lines @@
     // We should immediately get the final zoom and scroll values for the
     // animation.
     m_hostImpl->animate(halfwayThroughAnimation, base::Time());
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     expectContains(*scrollInfo, scrollLayer->id(), scaledTarget);
 
     // Scrolling during the animation is ignored.
     const gfx::Vector2d scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(target.x(), target.y()), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The final page scale and scroll deltas should match what we got
     // earlier.
     m_hostImpl->animate(endTime, base::Time());
     scrollInfo = m_hostImpl->processScrollDeltas();
     EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     expectContains(*scrollInfo, scrollLayer->id(), scaledTarget);
 }
 
@@ skipping 253 matching lines @@
     scrollLayer->setContentBounds(surfaceSize);
     scrollLayer->setPosition(gfx::PointF(0, 0));
     scrollLayer->setAnchorPoint(gfx::PointF(0, 0));
     scrollLayer->addChild(contentLayer.Pass());
 
     m_hostImpl->setRootLayer(scrollLayer.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 1);
     root->setBounds(surfaceSize);
     root->setContentBounds(surfaceSize);
     root->addChild(createScrollableLayer(2, surfaceSize));
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+    m_hostImpl->scrollBy(0, gfx::Point(), gfx::Vector2d(0, 10));
     m_hostImpl->scrollEnd();
     EXPECT_TRUE(m_didRequestRedraw);
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollMissesChild)
 {
     gfx::Size surfaceSize(10, 10);
     scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl->activeTree(), 1);
     root->addChild(createScrollableLayer(2, surfaceSize));
@@ skipping 54 matching lines @@
     float pageScale = 2;
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale from main thread.
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
 
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled) {
         // The scale should apply to the scroll delta.
         expectedScrollDelta = gfx::ToFlooredVector2d(gfx::ScaleVector2d(expectedScrollDelta, pageScale));
     }
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
@@ skipping 32 matching lines @@
     scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     m_hostImpl->setPageScaleFactorAndLimits(1, 1, pageScale);
     initializeRendererAndDrawFrame();
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
     m_hostImpl->pinchGestureEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
@@ skipping 66 matching lines @@
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
 
     gfx::Vector2d scrollDelta(0, 10);
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(child->maxScrollOffset());
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     float pageScale = 2;
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
 
     drawOneFrame();
 
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled) {
         // The scale should apply to the scroll delta.
         expectedScrollDelta = gfx::ToFlooredVector2d(gfx::ScaleVector2d(expectedScrollDelta, pageScale));
@@ skipping 24 matching lines @@
     child->setScrollOffset(gfx::Vector2d(3, 0));
     child->addChild(grandChild.Pass());
 
     root->addChild(child.Pass());
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         gfx::Vector2d scrollDelta(-8, -7);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-        m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+        m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // The grand child should have scrolled up to its limit.
         LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
         LayerImpl* grandChild = child->children()[0];
         expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, -5));
 
         // The child should have only scrolled on the other axis.
@@ skipping 11 matching lines @@
 
     child->setScrollable(false);
     root->addChild(child.Pass());
 
     m_hostImpl->setRootLayer(root.Pass());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         gfx::Vector2d scrollDelta(0, 4);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-        m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+        m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
         m_hostImpl->scrollEnd();
 
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // Only the root should have scrolled.
         ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
@@ skipping 21 matching lines @@
     rotateTransform.Rotate(-90);
     m_hostImpl->rootLayer()->setTransform(rotateTransform);
 
     gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll to the right in screen coordinates with a gesture.
     gfx::Vector2d gestureScrollDelta(10, 0);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), gestureScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, gestureScrollDelta.x()));
 
     // Reset and scroll down with the wheel.
     m_hostImpl->rootLayer()->setScrollDelta(gfx::Vector2dF());
     gfx::Vector2d wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 TEST_P(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
 {
     setupScrollAndContentsLayers(gfx::Size(100, 100));
@@ skipping 13 matching lines @@
     m_hostImpl->rootLayer()->addChild(child.Pass());
 
     gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     {
         // Scroll down in screen coordinates with a gesture.
         gfx::Vector2d gestureScrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-        m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
+        m_hostImpl->scrollBy(0, gfx::Point(), gestureScrollDelta);
         m_hostImpl->scrollEnd();
 
         // The child layer should have scrolled down in its local coordinates an amount proportional to
         // the angle between it and the input scroll delta.
         gfx::Vector2d expectedScrollDelta(0, gestureScrollDelta.y() * std::cos(MathUtil::Deg2Rad(childLayerAngle)));
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
 
         // The root layer should not have scrolled, because the input delta was close to the layer's
         // axis of movement.
         EXPECT_EQ(scrollInfo->scrolls.size(), 1u);
     }
 
     {
         // Now reset and scroll the same amount horizontally.
         m_hostImpl->rootLayer()->children()[1]->setScrollDelta(gfx::Vector2dF());
         gfx::Vector2d gestureScrollDelta(10, 0);
         EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-        m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
+        m_hostImpl->scrollBy(0, gfx::Point(), gestureScrollDelta);
         m_hostImpl->scrollEnd();
 
         // The child layer should have scrolled down in its local coordinates an amount proportional to
         // the angle between it and the input scroll delta.
         gfx::Vector2d expectedScrollDelta(0, -gestureScrollDelta.x() * std::sin(MathUtil::Deg2Rad(childLayerAngle)));
         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
 
         // The root layer should have scrolled more, since the input scroll delta was mostly
         // orthogonal to the child layer's vertical scroll axis.
@@ skipping 12 matching lines @@
     scaleTransform.Scale(scale, scale);
     m_hostImpl->rootLayer()->setTransform(scaleTransform);
 
     gfx::Size surfaceSize(50, 50);
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates, but half he amount.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, scrollDelta.y() / scale));
 
     // Reset and scroll down with the wheel.
     m_hostImpl->rootLayer()->setScrollDelta(gfx::Vector2dF());
     gfx::Vector2d wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
-    m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The scale should not have been applied to the scroll delta.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
 }
 
 class BlendStateTrackerContext: public FakeWebGraphicsContext3D {
 public:
     BlendStateTrackerContext() : m_blend(false) { }
@@ skipping 2854 matching lines @@
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     m_didRequestCommit = false;
     m_didRequestRedraw = false;
 
     // This scroll will force the viewport to pan horizontally.
     gfx::Vector2d scrollDelta(5, 0);
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     EXPECT_EQ(true, m_didRequestCommit);
     EXPECT_EQ(true, m_didRequestRedraw);
 
     m_didRequestCommit = false;
     m_didRequestRedraw = false;
 
     // This scroll will force the viewport to pan vertically.
     scrollDelta = gfx::Vector2d(0, 5);
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     EXPECT_EQ(true, m_didRequestCommit);
     EXPECT_EQ(true, m_didRequestRedraw);
 }
 
 TEST_P(LayerTreeHostImplTest, pinchZoomPanViewportForcesCommitDeviceScaleFactor1)
 {
     pinchZoomPanViewportForcesCommitRedraw(1);
 }
@@ skipping 38 matching lines @@
     // so no point in continuing without it.
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     gfx::Vector2d scrollDelta(5, 0);
     // TODO(wjmaclean): Fix the math here so that the expectedTranslation is
     // scaled instead of the scroll input.
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(scrollDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
     EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
     // No change expected.
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
     // None of the scroll delta should have been used for document scroll.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectNone(*scrollInfo.get(), m_hostImpl->rootLayer()->id());
 
     // Test scroll in y-direction also.
     scrollDelta = gfx::Vector2d(0, 5);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     expectedTranslation = gfx::ScaleVector2d(scrollDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
     EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
     // No change expected.
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
     // None of the scroll delta should have been used for document scroll.
@@ skipping 46 matching lines @@
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     // Scroll document only: scrollDelta chosen to move document horizontally
     // to its max scroll offset.
     gfx::Vector2d scrollDelta(3, 0);
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedScrollDelta(scrollDelta);
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Verify we did not change the implTransform this time.
     EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
 
     // Further scrolling should move the pinchZoomViewport only.
     scrollDelta = gfx::Vector2d(2, 0);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     gfx::Vector2d expectedPanDelta(scrollDelta);
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedImplTransform);
 
     // The scroll delta on the main thread should not have been affected by this.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Perform same test sequence in y-direction also.
     // Document only scroll.
     scrollDelta = gfx::Vector2d(0, 4);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     expectedScrollDelta += scrollDelta;
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     // Verify we did not change the implTransform this time.
     EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
 
     // pinchZoomViewport scroll only.
     scrollDelta = gfx::Vector2d(0, 1);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     expectedPanDelta = scrollDelta;
     expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
     EXPECT_EQ(expectedImplTransform, m_hostImpl->rootLayer()->implTransform());
 
     // The scroll delta on the main thread should not have been affected by this.
@@ skipping 49 matching lines @@
     if (!m_hostImpl->settings().pageScalePinchZoomEnabled)
         return;
 
     // Scroll document and pann zoomViewport in one scroll-delta.
     gfx::Vector2d scrollDelta(5, 0);
     gfx::Vector2d scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     gfx::Vector2d expectedScrollDelta(gfx::Vector2d(3, 0)); // This component gets handled by document scroll.
     gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->maxScrollOffset());
 
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     gfx::Vector2d expectedPanDelta(2, 0); // This component gets handled by zoomViewport pan.
     gfx::Vector2dF expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
     expectedImplTransform.Translate(-expectedTranslation.x(), -expectedTranslation.y());
 
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedImplTransform);
 
     // Perform same test sequence in y-direction also.
     scrollDelta = gfx::Vector2d(0, 5);
     scrollDeltaInZoomedViewport = ToFlooredVector2d(gfx::ScaleVector2d(scrollDelta, m_hostImpl->totalPageScaleFactorForTesting()));
     expectedScrollDelta += gfx::Vector2d(0, 4); // This component gets handled by document scroll.
     EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
-    m_hostImpl->scrollBy(gfx::Point(), scrollDeltaInZoomedViewport);
+    m_hostImpl->scrollBy(0, gfx::Point(), scrollDeltaInZoomedViewport);
     m_hostImpl->scrollEnd();
     drawOneFrame();
 
     // The scroll delta is not scaled because the main thread did not scale.
     scrollInfo = m_hostImpl->processScrollDeltas(); // This component gets handled by zoomViewport pan.
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
     EXPECT_EQ(expectedMaxScroll, m_hostImpl->rootLayer()->maxScrollOffset());
 
     expectedPanDelta = gfx::Vector2d(0, 1);
     expectedTranslation = gfx::ScaleVector2d(expectedPanDelta, m_hostImpl->deviceScaleFactor());
@@ skipping 50 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc