cc: Convert processScrollDeltas() to scoped_ptr<>.

cc/CCLayerTreeHostImplTest.cpp

 // 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 "config.h"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCDelegatedRendererLayerImpl.h"
@@ skipping 229 matching lines @@
     m_hostImpl->resetContentsTexturesPurged();
     EXPECT_TRUE(m_hostImpl->canDraw());
     EXPECT_TRUE(m_onCanDrawStateChangedCalled);
     m_onCanDrawStateChangedCalled = false;
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollDeltaNoLayers)
 {
     ASSERT_FALSE(m_hostImpl->rootLayer());
 
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
 {
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->addChild(CCLayerImpl::create(2));
         root->addChild(CCLayerImpl::create(3));
         root->children()[1]->addChild(CCLayerImpl::create(4));
         root->children()[1]->addChild(CCLayerImpl::create(5));
         root->children()[1]->children()[0]->addChild(CCLayerImpl::create(6));
         m_hostImpl->setRootLayer(root.release());
     }
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     expectClearedScrollDeltasRecursive(root);
 
-    OwnPtr<CCScrollAndScaleSet> scrollInfo;
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo;
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
     expectClearedScrollDeltasRecursive(root);
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollDeltaRepeatedScrolls)
 {
     IntPoint scrollPosition(20, 30);
     IntSize scrollDelta(11, -15);
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setScrollPosition(scrollPosition);
         root->setScrollable(true);
         root->setMaxScrollPosition(IntSize(100, 100));
         root->scrollBy(scrollDelta);
         m_hostImpl->setRootLayer(root.release());
     }
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
-    OwnPtr<CCScrollAndScaleSet> scrollInfo;
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo;
 
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
     EXPECT_EQ(root->sentScrollDelta(), scrollDelta);
     expectContains(*scrollInfo, root->id(), scrollDelta);
 
     IntSize scrollDelta2(-5, 27);
     root->scrollBy(scrollDelta2);
     scrollInfo = m_hostImpl->processScrollDeltas();
     ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
@@ skipping 50 matching lines @@
     // We should not crash if the tree is replaced while we are scrolling.
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->detachLayerTree();
 
     setupScrollAndContentsLayers(IntSize(100, 100));
 
     // We should still be scrolling, because the scrolled layer also exists in the new tree.
     IntSize scrollDelta(0, 10);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo, scrollLayerId, scrollDelta);
 }
 
 TEST_P(CCLayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     // We should be able to scroll even if the root layer loses its render surface after the most
@@ skipping 112 matching lines @@
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
         m_hostImpl->pinchGestureEnd();
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
 
         EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), IntSize(50, 50));
     }
 
     // Scrolling after a pinch gesture should always be in local space.  The scroll deltas do not
     // have the page scale factor applied.
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
         m_hostImpl->pinchGestureEnd();
 
         IntSize scrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), scrollDelta);
         m_hostImpl->scrollEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, pinchGesture)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
@@ skipping 10 matching lines @@
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
 
         float pageScaleDelta = 2;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
         m_hostImpl->pinchGestureEnd();
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
     }
 
     // Zoom-in clamping
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         float pageScaleDelta = 10;
 
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(50, 50));
         m_hostImpl->pinchGestureEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, maxPageScale);
     }
 
     // Zoom-out clamping
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         float pageScaleDelta = 0.1f;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(0, 0));
         m_hostImpl->pinchGestureEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
 
         if (!CCSettings::pageScalePinchZoomEnabled()) {
             // Pushed to (0,0) via clamping against contents layer size.
             expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
         } else {
             EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
         }
     }
 
     // Two-finger panning
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollDelta(IntSize());
         scrollLayer->setScrollPosition(IntPoint(20, 20));
 
         float pageScaleDelta = 1;
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(10, 10));
         m_hostImpl->pinchGestureUpdate(pageScaleDelta, IntPoint(20, 20));
         m_hostImpl->pinchGestureEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-10, -10));
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, pageScaleAnimation)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
@@ skipping 14 matching lines @@
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         m_hostImpl->startPageScaleAnimation(IntSize(0, 0), false, 2, startTime, duration);
         m_hostImpl->animate(halfwayThroughAnimation, halfwayThroughAnimation);
         EXPECT_TRUE(m_didRequestRedraw);
         m_hostImpl->animate(endTime, endTime);
         EXPECT_TRUE(m_didRequestCommit);
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 2);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
     }
 
     // Anchor zoom-out
     {
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         scrollLayer->setImplTransform(identityScaleTransform);
         scrollLayer->setScrollPosition(IntPoint(50, 50));
 
         m_hostImpl->startPageScaleAnimation(IntSize(25, 25), true, minPageScale, startTime, duration);
         m_hostImpl->animate(endTime, endTime);
         EXPECT_TRUE(m_didRequestRedraw);
         EXPECT_TRUE(m_didRequestCommit);
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
         // Pushed to (0,0) via clamping against contents layer size.
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(-50, -50));
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, inhibitScrollAndPageScaleUpdatesWhilePinchZooming)
 {
     setupScrollAndContentsLayers(IntSize(100, 100));
     m_hostImpl->setViewportSize(IntSize(50, 50), IntSize(50, 50));
     initializeRendererAndDrawFrame();
 
     CCLayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
     ASSERT(scrollLayer);
 
     const float minPageScale = CCSettings::pageScalePinchZoomEnabled() ? 1 : 0.5;
     const float maxPageScale = 4;
 
     // Pinch zoom in.
     {
         // Start a pinch in gesture at the bottom right corner of the viewport.
         const float zoomInDelta = 2;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(zoomInDelta, IntPoint(50, 50));
 
         // Because we are pinch zooming in, we shouldn't get any scroll or page
         // scale deltas.
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
         EXPECT_EQ(scrollInfo->scrolls.size(), 0u);
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
         scrollInfo = m_hostImpl->processScrollDeltas();
         EXPECT_EQ(scrollInfo->pageScaleDelta, zoomInDelta);
         if (!CCSettings::pageScalePinchZoomEnabled()) {
             expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
         } else {
             EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
         }
     }
 
     // Pinch zoom out.
     {
         // Start a pinch out gesture at the bottom right corner of the viewport.
         const float zoomOutDelta = 0.75;
         m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
         m_hostImpl->pinchGestureBegin();
         m_hostImpl->pinchGestureUpdate(zoomOutDelta, IntPoint(50, 50));
 
         // Since we are pinch zooming out, we should get an update to zoom all
         // the way out to the minimum page scale.
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
         if (!CCSettings::pageScalePinchZoomEnabled()) {
             EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
             expectContains(*scrollInfo, scrollLayer->id(), IntSize(0, 0));
         } else {
             EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
             EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
         }
 
         // Once the gesture ends, we get the final scroll and page scale values.
         m_hostImpl->pinchGestureEnd();
@@ skipping 25 matching lines @@
     const double endTime = startTime + duration;
 
     // Start a page scale animation.
     const float pageScaleDelta = 2;
     m_hostImpl->setPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
     m_hostImpl->startPageScaleAnimation(IntSize(50, 50), false, pageScaleDelta, startTime, duration);
 
     // We should immediately get the final zoom and scroll values for the
     // animation.
     m_hostImpl->animate(halfwayThroughAnimation, halfwayThroughAnimation);
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
     if (!CCSettings::pageScalePinchZoomEnabled()) {
         EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
         expectContains(*scrollInfo, scrollLayer->id(), IntSize(25, 25));
     } else {
         EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
         EXPECT_TRUE(scrollInfo->scrolls.isEmpty());
     }
 
     // Scrolling during the animation is ignored.
@@ skipping 366 matching lines @@
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale from main thread.
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
 
     if (!CCSettings::pageScalePinchZoomEnabled()) {
         // The scale should apply to the scroll delta.
         expectedScrollDelta.scale(pageScale);
     }
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), WebTransformationMatrix());
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
@@ skipping 13 matching lines @@
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // Set new page scale on impl thread by pinching.
     m_hostImpl->pinchGestureBegin();
     m_hostImpl->pinchGestureUpdate(pageScale, IntPoint());
     m_hostImpl->pinchGestureEnd();
     m_hostImpl->updateRootScrollLayerImplTransform();
 
     // The scroll delta is not scaled because the main thread did not scale.
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
 
     // The scroll range should also have been updated.
     EXPECT_EQ(m_hostImpl->rootLayer()->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta should match the new scale on the impl side.
     WebTransformationMatrix expectedScale;
     expectedScale.scale(pageScale);
     EXPECT_EQ(m_hostImpl->rootLayer()->implTransform(), expectedScale);
 }
@@ skipping 68 matching lines @@
 
     float pageScale = 2;
     m_hostImpl->setPageScaleFactorAndLimits(pageScale, 1, pageScale);
 
     m_hostImpl->updateRootScrollLayerImplTransform();
 
     if (!CCSettings::pageScalePinchZoomEnabled()) {
         // The scale should apply to the scroll delta.
         expectedScrollDelta.scale(pageScale);
     }
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
 
     // The scroll range should not have changed.
     EXPECT_EQ(child->maxScrollPosition(), expectedMaxScroll);
 
     // The page scale delta remains constant because the impl thread did not scale.
     WebTransformationMatrix identityTransform;
     EXPECT_EQ(child->implTransform(), WebTransformationMatrix());
 }
 
@@ skipping 15 matching lines @@
     root->addChild(child.release());
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         IntSize scrollDelta(-8, -7);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), scrollDelta);
         m_hostImpl->scrollEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // The grand child should have scrolled up to its limit.
         CCLayerImpl* child = m_hostImpl->rootLayer()->children()[0];
         CCLayerImpl* grandChild = child->children()[0];
         expectContains(*scrollInfo.get(), grandChild->id(), IntSize(0, -5));
 
         // The child should have only scrolled on the other axis.
         expectContains(*scrollInfo.get(), child->id(), IntSize(-3, 0));
     }
 }
@@ skipping 11 matching lines @@
 
     m_hostImpl->setRootLayer(root.release());
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
     {
         IntSize scrollDelta(0, 4);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(5, 5), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), scrollDelta);
         m_hostImpl->scrollEnd();
 
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
 
         // Only the root should have scrolled.
         ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollBeforeRedraw)
 {
     IntSize surfaceSize(10, 10);
@@ skipping 22 matching lines @@
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll to the right in screen coordinates with a gesture.
     IntSize gestureScrollDelta(10, 0);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), gestureScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), IntSize(0, gestureScrollDelta.width()));
 
     // Reset and scroll down with the wheel.
     m_hostImpl->rootLayer()->setScrollDelta(FloatSize());
     IntSize wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates.
@@ skipping 26 matching lines @@
     {
         // Scroll down in screen coordinates with a gesture.
         IntSize gestureScrollDelta(0, 10);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), 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.
         IntSize expectedScrollDelta(0, gestureScrollDelta.height() * cosf(deg2rad(childLayerAngle)));
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> 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(FloatSize());
         IntSize gestureScrollDelta(10, 0);
         EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
         m_hostImpl->scrollBy(IntPoint(), 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.
         IntSize expectedScrollDelta(0, -gestureScrollDelta.width() * sinf(deg2rad(childLayerAngle)));
-        OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+        scoped_ptr<CCScrollAndScaleSet> 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.
         IntSize expectedRootScrollDelta(gestureScrollDelta.width() * pow(cosf(deg2rad(childLayerAngle)), 2), 0);
         expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedRootScrollDelta);
     }
 }
 
 TEST_P(CCLayerTreeHostImplTest, scrollScaledLayer)
@@ skipping 10 matching lines @@
     m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
     initializeRendererAndDrawFrame();
 
     // Scroll down in screen coordinates with a gesture.
     IntSize scrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Gesture), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), scrollDelta);
     m_hostImpl->scrollEnd();
 
     // The layer should have scrolled down in its local coordinates, but half he amount.
-    OwnPtr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+    scoped_ptr<CCScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
     expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), IntSize(0, scrollDelta.height() / scale));
 
     // Reset and scroll down with the wheel.
     m_hostImpl->rootLayer()->setScrollDelta(FloatSize());
     IntSize wheelScrollDelta(0, 10);
     EXPECT_EQ(m_hostImpl->scrollBegin(IntPoint(0, 0), CCInputHandlerClient::Wheel), CCInputHandlerClient::ScrollStarted);
     m_hostImpl->scrollBy(IntPoint(), wheelScrollDelta);
     m_hostImpl->scrollEnd();
 
     // The scale should not have been applied to the scroll delta.
@@ skipping 2848 matching lines @@
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 INSTANTIATE_TEST_CASE_P(CCLayerTreeHostImplTests,
                         CCLayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 } // namespace