[cc] Store CCLayerImpls as scoped_ptrs

cc/CCLayerTreeHostCommonTest.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 "CCLayerTreeHostCommon.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCGeometryTestUtils.h"
@@ skipping 74 matching lines @@
     ret.setM13(0);
     ret.setM23(0);
     ret.setM31(0);
     ret.setM32(0);
     ret.setM33(1);
     ret.setM34(0);
     ret.setM43(0);
     return ret;
 }
 
-PassOwnPtr<CCLayerImpl> createTreeForFixedPositionTests()
+scoped_ptr<CCLayerImpl> createTreeForFixedPositionTests()
 {
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
-    OwnPtr<CCLayerImpl> child = CCLayerImpl::create(2);
-    OwnPtr<CCLayerImpl> grandChild = CCLayerImpl::create(3);
-    OwnPtr<CCLayerImpl> greatGrandChild = CCLayerImpl::create(4);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> child = CCLayerImpl::create(2);
+    scoped_ptr<CCLayerImpl> grandChild = CCLayerImpl::create(3);
+    scoped_ptr<CCLayerImpl> greatGrandChild = CCLayerImpl::create(4);
 
     WebTransformationMatrix IdentityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(child.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(grandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(greatGrandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
 
-    grandChild->addChild(greatGrandChild.release());
-    child->addChild(grandChild.release());
-    root->addChild(child.release());
+    grandChild->addChild(greatGrandChild.Pass());
+    child->addChild(grandChild.Pass());
+    root->addChild(child.Pass());
 
-    return root.release();
+    return root.Pass();
 }
 
 class LayerChromiumWithForcedDrawsContent : public LayerChromium {
 public:
     LayerChromiumWithForcedDrawsContent()
         : LayerChromium()
     {
     }
 
     virtual bool drawsContent() const OVERRIDE { return true; }
@@ skipping 608 matching lines @@
     EXPECT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDirectContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is the direct parent of the fixed-position layer.
 
     DebugScopedSetImplThread scopedImplThread;
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(IntSize(0, 0));
     executeCalculateDrawTransformsAndVisibility(root.get());
 
@@ skipping 20 matching lines @@
     // This test checks for correct scroll compensation when the fixed-position container
     // is the direct parent of the fixed-position layer, but that container is transformed.
     // In this case, the fixed position element inherits the container's transform,
     // but the scrollDelta that has to be undone should not be affected by that transform.
     //
     // Transforms are in general non-commutative; using something like a non-uniform scale
     // helps to verify that translations and non-uniform scales are applied in the correct
     // order.
 
     DebugScopedSetImplThread scopedImplThread;
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
 
     // This scale will cause child and grandChild to be effectively 200 x 800 with respect to the renderTarget.
     WebTransformationMatrix nonUniformScale;
     nonUniformScale.scaleNonUniform(2, 8);
     child->setTransform(nonUniformScale);
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
@@ skipping 22 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedChildTransform, child->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
     CCLayerImpl* greatGrandChild = grandChild->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(FloatPoint(8, 6));
     greatGrandChild->setFixedToContainerLayer(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(IntSize(0, 0));
@@ skipping 23 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGreatGrandChildTransform, greatGrandChild->drawTransform());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDistantContainerAndTransforms)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
     CCLayerImpl* greatGrandChild = grandChild->children()[0];
 
     WebTransformationMatrix rotationAboutZ;
     rotationAboutZ.rotate3d(0, 0, 90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(FloatPoint(8, 6));
@@ skipping 41 matching lines @@
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // has multiple ancestors that have nonzero scrollDelta before reaching the space where the layer is fixed.
     // In this test, each scrollDelta occurs in a different space because of each layer's local transform.
     // This test checks for correct scroll compensation when the fixed-position container
     // is NOT the direct parent of the fixed-position layer, and the hierarchy has various
     // transforms that have to be processed in the correct order.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
     CCLayerImpl* greatGrandChild = grandChild->children()[0];
 
     WebTransformationMatrix rotationAboutZ;
     rotationAboutZ.rotate3d(0, 0, 90);
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setTransform(rotationAboutZ);
     grandChild->setPosition(FloatPoint(8, 6));
@@ skipping 41 matching lines @@
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithIntermediateSurfaceAndTransforms)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // contributes to a different renderSurface than the fixed-position layer. In this
     // case, the surface drawTransforms also have to be accounted for when checking the
     // scrollDelta.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
     CCLayerImpl* greatGrandChild = grandChild->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(FloatPoint(8, 6));
     grandChild->setForceRenderSurface(true);
     greatGrandChild->setFixedToContainerLayer(true);
     greatGrandChild->setDrawsContent(true);
 
@@ skipping 52 matching lines @@
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // contributes to a different renderSurface than the fixed-position layer, with
     // additional renderSurfaces in-between. This checks that the conversion to ancestor
     // surfaces is accumulated properly in the final matrix transform.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
     CCLayerImpl* greatGrandChild = grandChild->children()[0];
 
     // Add one more layer to the test tree for this scenario.
     {
         WebTransformationMatrix identity;
-        OwnPtr<CCLayerImpl> fixedPositionChild = CCLayerImpl::create(5);
+        scoped_ptr<CCLayerImpl> fixedPositionChild = CCLayerImpl::create(5);
         setLayerPropertiesForTesting(fixedPositionChild.get(), identity, identity, FloatPoint(0, 0), FloatPoint(0, 0), IntSize(100, 100), false);
-        greatGrandChild->addChild(fixedPositionChild.release());
+        greatGrandChild->addChild(fixedPositionChild.Pass());
     }
     CCLayerImpl* fixedPositionChild = greatGrandChild->children()[0];
 
     // Actually set up the scenario here.
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setPosition(FloatPoint(8, 6));
     grandChild->setForceRenderSurface(true);
     greatGrandChild->setPosition(FloatPoint(40, 60));
     greatGrandChild->setForceRenderSurface(true);
     fixedPositionChild->setFixedToContainerLayer(true);
@@ skipping 80 matching lines @@
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // itself has a renderSurface. In this case, the container layer should be treated
     // like a layer that contributes to a renderTarget, and that renderTarget
     // is completely irrelevant; it should not affect the scroll compensation.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     child->setForceRenderSurface(true);
     grandChild->setFixedToContainerLayer(true);
     grandChild->setDrawsContent(true);
 
     // Case 1: scrollDelta of 0, 0
     child->setScrollDelta(IntSize(0, 0));
@@ skipping 26 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer)
 {
     // This test checks the scenario where a fixed-position layer also happens to be a
     // container itself for a descendant fixed position layer. In particular, the layer
     // should not accidentally be fixed to itself.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
 
     child->setIsContainerForFixedPositionLayers(true);
     grandChild->setFixedToContainerLayer(true);
 
     // This should not confuse the grandChild. If correct, the grandChild would still be considered fixed to its container (i.e. "child").
     grandChild->setIsContainerForFixedPositionLayers(true);
 
     // Case 1: scrollDelta of 0, 0
@@ skipping 16 matching lines @@
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedGrandChildTransform, grandChild->drawTransform());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerThatHasNoContainer)
 {
     // This test checks scroll compensation when a fixed-position layer does not find any
     // ancestor that is a "containerForFixedPositionLayers". In this situation, the layer should
     // be fixed to the viewport -- not the rootLayer, which may have transforms of its own.
     DebugScopedSetImplThread scopedImplThread;
 
-    OwnPtr<CCLayerImpl> root = createTreeForFixedPositionTests();
+    scoped_ptr<CCLayerImpl> root = createTreeForFixedPositionTests();
     CCLayerImpl* child = root->children()[0];
     CCLayerImpl* grandChild = child->children()[0];
 
     WebTransformationMatrix rotationByZ;
     rotationByZ.rotate3d(0, 0, 90);
 
     root->setTransform(rotationByZ);
     grandChild->setFixedToContainerLayer(true);
 
     // Case 1: root scrollDelta of 0, 0
@@ skipping 1372 matching lines @@
 
     testPoint = IntPoint(10, 20);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForSingleLayer)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(12345);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(12345);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
@@ skipping 22 matching lines @@
     testPoint = IntPoint(99, 99);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForUninvertibleTransform)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(12345);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(12345);
 
     WebTransformationMatrix uninvertibleTransform;
     uninvertibleTransform.setM11(0);
     uninvertibleTransform.setM22(0);
     uninvertibleTransform.setM33(0);
     uninvertibleTransform.setM44(0);
     ASSERT_FALSE(uninvertibleTransform.isInvertible());
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
@@ skipping 41 matching lines @@
 
     testPoint = IntPoint(-1, -1);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForSinglePositionedLayer)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(12345);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(12345);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
@@ skipping 23 matching lines @@
     testPoint = IntPoint(99, 99);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForSingleRotatedLayer)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(12345);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(12345);
 
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix rotation45DegreesAboutCenter;
     rotation45DegreesAboutCenter.translate(50, 50);
     rotation45DegreesAboutCenter.rotate3d(0, 0, 45);
     rotation45DegreesAboutCenter.translate(-50, -50);
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
@@ skipping 31 matching lines @@
 
     testPoint = IntPoint(-1, 50);
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_FALSE(resultLayer);
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForSinglePerspectiveLayer)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(12345);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(12345);
 
     WebTransformationMatrix identityMatrix;
 
     // perspectiveProjectionAboutCenter * translationByZ is designed so that the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
     WebTransformationMatrix perspectiveProjectionAboutCenter;
     perspectiveProjectionAboutCenter.translate(50, 50);
     perspectiveProjectionAboutCenter.applyPerspective(1);
     perspectiveProjectionAboutCenter.translate(-50, -50);
     WebTransformationMatrix translationByZ;
     translationByZ.translate3d(0, 0, -1);
@@ skipping 42 matching lines @@
     // test makes sure that hit testing works correctly accounts for the contents scale.
     // A contentsScale that is not 1 effectively forces a non-identity transform between
     // layer's content space and layer's origin space. The hit testing code must take this into account.
     //
     // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
     // contentsScale is ignored, then hit testing will mis-interpret the visibleContentRect
     // as being larger than the actual bounds of the layer.
     //
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
 
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, FloatPoint(0, 0), IntSize(100, 100), false);
 
     {
         FloatPoint position(25, 25);
         IntSize bounds(50, 50);
-        OwnPtr<CCLayerImpl> testLayer = CCLayerImpl::create(12345);
+        scoped_ptr<CCLayerImpl> testLayer = CCLayerImpl::create(12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
         // override contentBounds
         testLayer->setContentBounds(IntSize(100, 100));
 
         testLayer->setDrawsContent(true);
-        root->addChild(testLayer.release());
+        root->addChild(testLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     CCLayerImpl* testLayer = root->children()[0];
@@ skipping 28 matching lines @@
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForSimpleClippedLayer)
 {
     // Test that hit-testing will only work for the visible portion of a layer, and not
     // the entire layer bounds. Here we just test the simple axis-aligned case.
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, FloatPoint(0, 0), IntSize(100, 100), false);
 
     {
-        OwnPtr<CCLayerImpl> clippingLayer = CCLayerImpl::create(123);
+        scoped_ptr<CCLayerImpl> clippingLayer = CCLayerImpl::create(123);
         FloatPoint position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
         IntSize bounds(50, 50);
         setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         clippingLayer->setMasksToBounds(true);
 
-        OwnPtr<CCLayerImpl> child = CCLayerImpl::create(456);
+        scoped_ptr<CCLayerImpl> child = CCLayerImpl::create(456);
         position = FloatPoint(-50, -50);
         bounds = IntSize(300, 300);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
-        clippingLayer->addChild(child.release());
-        root->addChild(clippingLayer.release());
+        clippingLayer->addChild(child.Pass());
+        root->addChild(clippingLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
@@ skipping 29 matching lines @@
     // algorithm needs to recognize that multiple parent layers may clip the layer, and
     // should not actually hit those clipped areas.
     //
     // The child and grandChild layers are both initialized to clip the rotatedLeaf. The
     // child layer is rotated about the top-left corner, so that the root + child clips
     // combined create a triangle. The rotatedLeaf will only be visible where it overlaps
     // this triangle.
     //
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(123);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(123);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setMasksToBounds(true);
 
     {
-        OwnPtr<CCLayerImpl> child = CCLayerImpl::create(456);
-        OwnPtr<CCLayerImpl> grandChild = CCLayerImpl::create(789);
-        OwnPtr<CCLayerImpl> rotatedLeaf = CCLayerImpl::create(2468);
+        scoped_ptr<CCLayerImpl> child = CCLayerImpl::create(456);
+        scoped_ptr<CCLayerImpl> grandChild = CCLayerImpl::create(789);
+        scoped_ptr<CCLayerImpl> rotatedLeaf = CCLayerImpl::create(2468);
 
         position = FloatPoint(10, 10);
         bounds = IntSize(80, 80);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setMasksToBounds(true);
         
         WebTransformationMatrix rotation45DegreesAboutCorner;
         rotation45DegreesAboutCorner.rotate3d(0, 0, 45);
 
         position = FloatPoint(0, 0); // remember, positioned with respect to its parent which is already at 10, 10
         bounds = IntSize(200, 200); // to ensure it covers at least sqrt(2) * 100.
         setLayerPropertiesForTesting(grandChild.get(), rotation45DegreesAboutCorner, identityMatrix, anchor, position, bounds, false);
         grandChild->setMasksToBounds(true);
 
         // Rotates about the center of the layer
         WebTransformationMatrix rotatedLeafTransform;
         rotatedLeafTransform.translate(-10, -10); // cancel out the grandParent's position
         rotatedLeafTransform.rotate3d(0, 0, -45); // cancel out the corner 45-degree rotation of the parent.
         rotatedLeafTransform.translate(50, 50);
         rotatedLeafTransform.rotate3d(0, 0, 45);
         rotatedLeafTransform.translate(-50, -50);
         position = FloatPoint(0, 0);
         bounds = IntSize(100, 100);
         setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
         rotatedLeaf->setDrawsContent(true);
 
-        grandChild->addChild(rotatedLeaf.release());
-        child->addChild(grandChild.release());
-        root->addChild(child.release());
+        grandChild->addChild(rotatedLeaf.Pass());
+        child->addChild(grandChild.Pass());
+        root->addChild(child.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The grandChild is expected to create a renderSurface because it masksToBounds and is not axis aligned.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
@@ skipping 42 matching lines @@
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForNonClippingIntermediateLayer)
 {
     // This test checks that hit testing code does not accidentally clip to layer
     // bounds for a layer that actually does not clip.
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, FloatPoint(0, 0), IntSize(100, 100), false);
 
     {
-        OwnPtr<CCLayerImpl> intermediateLayer = CCLayerImpl::create(123);
+        scoped_ptr<CCLayerImpl> intermediateLayer = CCLayerImpl::create(123);
         FloatPoint position(10, 10); // this layer is positioned, and hit testing should correctly know where the layer is located.
         IntSize bounds(50, 50);
         setLayerPropertiesForTesting(intermediateLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         // Sanity check the intermediate layer should not clip.
         ASSERT_FALSE(intermediateLayer->masksToBounds());
         ASSERT_FALSE(intermediateLayer->maskLayer());
 
         // The child of the intermediateLayer is translated so that it does not overlap intermediateLayer at all.
         // If child is incorrectly clipped, we would not be able to hit it successfully.
-        OwnPtr<CCLayerImpl> child = CCLayerImpl::create(456);
+        scoped_ptr<CCLayerImpl> child = CCLayerImpl::create(456);
         position = FloatPoint(60, 60); // 70, 70 in screen space
         bounds = IntSize(20, 20);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
-        intermediateLayer->addChild(child.release());
-        root->addChild(intermediateLayer.release());
+        intermediateLayer->addChild(child.Pass());
+        root->addChild(intermediateLayer.Pass());
     }
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
@@ skipping 18 matching lines @@
     resultLayer = CCLayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(456, resultLayer->id());
 }
 
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForMultipleLayers)
 {
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
         //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
 
-        OwnPtr<CCLayerImpl> child1 = CCLayerImpl::create(2);
-        OwnPtr<CCLayerImpl> child2 = CCLayerImpl::create(3);
-        OwnPtr<CCLayerImpl> grandChild1 = CCLayerImpl::create(4);
+        scoped_ptr<CCLayerImpl> child1 = CCLayerImpl::create(2);
+        scoped_ptr<CCLayerImpl> child2 = CCLayerImpl::create(3);
+        scoped_ptr<CCLayerImpl> grandChild1 = CCLayerImpl::create(4);
 
         position = FloatPoint(10, 10);
         bounds = IntSize(50, 50);
         setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child1->setDrawsContent(true);
 
         position = FloatPoint(50, 10);
         bounds = IntSize(50, 50);
         setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child2->setDrawsContent(true);
 
         // Remember that grandChild is positioned with respect to its parent (i.e. child1).
         // In screen space, the intended position is (10, 50), with size 100 x 50.
         position = FloatPoint(0, 40);
         bounds = IntSize(100, 50);
         setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         grandChild1->setDrawsContent(true);
 
-        child1->addChild(grandChild1.release());
-        root->addChild(child1.release());
-        root->addChild(child2.release());
+        child1->addChild(grandChild1.Pass());
+        root->addChild(child1.Pass());
+        root->addChild(child2.Pass());
     }
 
     CCLayerImpl* child1 = root->children()[0];
     CCLayerImpl* child2 = root->children()[1];
     CCLayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
@@ skipping 47 matching lines @@
 }
 
 TEST(CCLayerTreeHostCommonTest, verifyHitTestingForMultipleLayerLists)
 {
     //
     // The geometry is set up similarly to the previous case, but
     // all layers are forced to be renderSurfaces now.
     //
     DebugScopedSetImplThread thisScopeIsOnImplThread;
 
-    OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
+    scoped_ptr<CCLayerImpl> root = CCLayerImpl::create(1);
 
     WebTransformationMatrix identityMatrix;
     FloatPoint anchor(0, 0);
     FloatPoint position(0, 0);
     IntSize bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
         //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
 
-        OwnPtr<CCLayerImpl> child1 = CCLayerImpl::create(2);
-        OwnPtr<CCLayerImpl> child2 = CCLayerImpl::create(3);
-        OwnPtr<CCLayerImpl> grandChild1 = CCLayerImpl::create(4);
+        scoped_ptr<CCLayerImpl> child1 = CCLayerImpl::create(2);
+        scoped_ptr<CCLayerImpl> child2 = CCLayerImpl::create(3);
+        scoped_ptr<CCLayerImpl> grandChild1 = CCLayerImpl::create(4);
 
         position = FloatPoint(10, 10);
         bounds = IntSize(50, 50);
         setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child1->setDrawsContent(true);
         child1->setForceRenderSurface(true);
 
         position = FloatPoint(50, 10);
         bounds = IntSize(50, 50);
         setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child2->setDrawsContent(true);
         child2->setForceRenderSurface(true);
 
         // Remember that grandChild is positioned with respect to its parent (i.e. child1).
         // In screen space, the intended position is (10, 50), with size 100 x 50.
         position = FloatPoint(0, 40);
         bounds = IntSize(100, 50);
         setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         grandChild1->setDrawsContent(true);
         grandChild1->setForceRenderSurface(true);
 
-        child1->addChild(grandChild1.release());
-        root->addChild(child1.release());
-        root->addChild(child2.release());
+        child1->addChild(grandChild1.Pass());
+        root->addChild(child1.Pass());
+        root->addChild(child2.Pass());
     }
 
     CCLayerImpl* child1 = root->children()[0];
     CCLayerImpl* child2 = root->children()[1];
     CCLayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<CCLayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     CCLayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
@@ skipping 223 matching lines @@
     int nonexistentId = -1;
     EXPECT_EQ(root, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
     EXPECT_EQ(child, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
     EXPECT_EQ(grandChild, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
     EXPECT_EQ(maskLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
     EXPECT_EQ(replicaLayer, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
     EXPECT_EQ(0, CCLayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
 }
 
 } // namespace