Add wrapper container for a vector of OwnPtr<T>

cc/CCDamageTrackerTest.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 "CCDamageTracker.h"
 
 #include "CCGeometryTestUtils.h"
 #include "CCLayerImpl.h"
@@ skipping 27 matching lines @@
     CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList);
 }
 
 void clearDamageForAllSurfaces(CCLayerImpl* layer)
 {
     if (layer->renderSurface())
         layer->renderSurface()->damageTracker()->didDrawDamagedArea();
 
     // Recursively clear damage for any existing surface.
     for (size_t i = 0; i < layer->children().size(); ++i)
-        clearDamageForAllSurfaces(layer->children()[i].get());
+        clearDamageForAllSurfaces(layer->children()[i]);
 }
 
 void emulateDrawingOneFrame(CCLayerImpl* root)
 {
     // This emulates only the steps that are relevant to testing the damage tracker:
     //   1. computing the render passes and layerlists
     //   2. updating all damage trackers in the correct order
     //   3. resetting all updateRects and propertyChanged flags for all layers and surfaces.
 
     Vector<CCLayerImpl*> renderSurfaceLayerList;
@@ skipping 127 matching lines @@
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 500, 500), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, sanityCheckTestTreeWithTwoSurfaces)
 {
     // Sanity check that the complex test tree will actually produce the expected render
     // surfaces and layer lists.
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
 
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* child2 = root->children()[1].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* child2 = root->children()[1];
     FloatRect childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
 
     ASSERT_TRUE(child1->renderSurface());
     EXPECT_FALSE(child2->renderSurface());
     EXPECT_EQ(3u, root->renderSurface()->layerList().size());
     EXPECT_EQ(2u, child1->renderSurface()->layerList().size());
 
     // The render surface for child1 only has a contentRect that encloses grandChild1 and grandChild2, because child1 does not draw content.
     EXPECT_FLOAT_RECT_EQ(FloatRect(190, 190, 16, 18), childDamageRect);
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 500, 500), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForUpdateRects)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     // CASE 1: Setting the update rect should cause the corresponding damage to the surface.
     //
     clearDamageForAllSurfaces(root.get());
     child->setUpdateRect(FloatRect(10, 11, 12, 13));
     emulateDrawingOneFrame(root.get());
 
     // Damage position on the surface should be: position of updateRect (10, 11) relative to the child (100, 100).
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(110, 111, 12, 13), rootDamageRect);
@@ skipping 13 matching lines @@
     emulateDrawingOneFrame(root.get());
 
     // Damage position on the surface should be: position of updateRect (20, 25) relative to the child (100, 100).
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(120, 125, 1, 2), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForPropertyChanges)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     // CASE 1: The layer's property changed flag takes priority over update rect.
     //
     clearDamageForAllSurfaces(root.get());
     child->setUpdateRect(FloatRect(10, 11, 12, 13));
     child->setOpacity(0.5);
     emulateDrawingOneFrame(root.get());
 
     // Sanity check - we should not have accidentally created a separate render surface for the translucent layer.
     ASSERT_FALSE(child->renderSurface());
@@ skipping 23 matching lines @@
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(expectedRect, rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForTransformedLayer)
 {
     // If a layer is transformed, the damage rect should still enclose the entire
     // transformed layer.
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     WebTransformationMatrix rotation;
     rotation.rotate(45);
 
     clearDamageForAllSurfaces(root.get());
     child->setAnchorPoint(FloatPoint(0.5, 0.5));
     child->setPosition(FloatPoint(85, 85));
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that the layer actually moved to (85, 85), damaging its old location and new location.
@@ skipping 22 matching lines @@
     // layer can cause an invalid damage rect. This test checks that the w < 0 case is
     // tracked properly.
     //
     // The transform is constructed so that if w < 0 clipping is not performed, the
     // incorrect rect will be very small, specifically: position (500.972504, 498.544617) and size 0.056610 x 2.910767.
     // Instead, the correctly transformed rect should actually be very huge (i.e. in theory, -infinity on the left),
     // and positioned so that the right-most bound rect will be approximately 501 units in root surface space.
     //
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     WebTransformationMatrix transform;
     transform.translate3d(500, 500, 0);
     transform.applyPerspective(1);
     transform.rotate3d(0, 45, 0);
     transform.translate3d(-50, -50, 0);
 
     // Set up the child
     child->setPosition(FloatPoint(0, 0));
     child->setBounds(IntSize(100, 100));
@@ skipping 16 matching lines @@
     // The expected damage should cover the entire root surface (500x500), but we don't
     // care whether the damage rect was clamped or is larger than the surface for this test.
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     FloatRect damageWeCareAbout = FloatRect(FloatPoint::zero(), FloatSize(500, 500));
     EXPECT_TRUE(rootDamageRect.contains(damageWeCareAbout));
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForBlurredSurface)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     WebFilterOperations filters;
     filters.append(WebFilterOperation::createBlurFilter(5));
     int outsetTop, outsetRight, outsetBottom, outsetLeft;
     filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
     // Setting the filter will damage the whole surface.
     clearDamageForAllSurfaces(root.get());
     root->setFilters(filters);
     emulateDrawingOneFrame(root.get());
 
     // Setting the update rect should cause the corresponding damage to the surface, blurred based on the size of the blur filter.
     clearDamageForAllSurfaces(root.get());
     child->setUpdateRect(FloatRect(10, 11, 12, 13));
     emulateDrawingOneFrame(root.get());
 
     // Damage position on the surface should be: position of updateRect (10, 11) relative to the child (100, 100), but expanded by the blur outsets.
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     FloatRect expectedDamageRect = FloatRect(110, 111, 12, 13);
     expectedDamageRect.move(-outsetLeft, -outsetTop);
     expectedDamageRect.expand(outsetLeft + outsetRight, outsetTop + outsetBottom);
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForBackgroundBlurredChild)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* child2 = root->children()[1].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* child2 = root->children()[1];
 
     // Allow us to set damage on child1 too.
     child1->setDrawsContent(true);
 
     WebFilterOperations filters;
     filters.append(WebFilterOperation::createBlurFilter(2));
     int outsetTop, outsetRight, outsetBottom, outsetLeft;
     filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
     // Setting the filter will damage the whole surface.
@@ skipping 81 matching lines @@
     // Damage on child1 should be: position of updateRect offset by the child's position (100, 100), and expanded by the damage.
     expectedDamageRect = FloatRect(100, 100, 1, 1);
     expectedDamageRect.move(-outsetLeft, -outsetTop);
     expectedDamageRect.expand(outsetLeft + outsetRight, outsetTop + outsetBottom);
     EXPECT_FLOAT_RECT_EQ(expectedDamageRect, rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForAddingAndRemovingLayer)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
 
     // CASE 1: Adding a new layer should cause the appropriate damage.
     //
     clearDamageForAllSurfaces(root.get());
     {
         OwnPtr<CCLayerImpl> child2 = CCLayerImpl::create(3);
         child2->setPosition(FloatPoint(400, 380));
         child2->setAnchorPoint(FloatPoint::zero());
         child2->setBounds(IntSize(6, 8));
         child2->setContentBounds(IntSize(6, 8));
@@ skipping 50 matching lines @@
     // Sanity check - all 3 layers should be on the same render surface; render surfaces are tested elsewhere.
     ASSERT_EQ(3u, root->renderSurface()->layerList().size());
 
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(400, 380, 6, 8), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForMultipleLayers)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
 
     // In this test we don't want the above tree manipulation to be considered part of the same frame.
     clearDamageForAllSurfaces(root.get());
     {
         OwnPtr<CCLayerImpl> child2 = CCLayerImpl::create(3);
         child2->setPosition(FloatPoint(400, 380));
         child2->setAnchorPoint(FloatPoint::zero());
         child2->setBounds(IntSize(6, 8));
         child2->setContentBounds(IntSize(6, 8));
         child2->setDrawsContent(true);
         root->addChild(child2.release());
     }
-    CCLayerImpl* child2 = root->children()[1].get();
+    CCLayerImpl* child2 = root->children()[1];
     emulateDrawingOneFrame(root.get());
 
     // Damaging two layers simultaneously should cause combined damage.
     // - child1 update rect in surface space: FloatRect(100, 100, 1, 2);
     // - child2 update rect in surface space: FloatRect(400, 380, 3, 4);
     clearDamageForAllSurfaces(root.get());
     child1->setUpdateRect(FloatRect(0, 0, 1, 2));
     child2->setUpdateRect(FloatRect(0, 0, 3, 4));
     emulateDrawingOneFrame(root.get());
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(100, 100, 303, 284), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForNestedSurfaces)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* child2 = root->children()[1].get();
-    CCLayerImpl* grandChild1 = root->children()[0]->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* child2 = root->children()[1];
+    CCLayerImpl* grandChild1 = root->children()[0]->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     // CASE 1: Damage to a descendant surface should propagate properly to ancestor surface.
     //
     clearDamageForAllSurfaces(root.get());
     grandChild1->setOpacity(0.5);
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
@@ skipping 16 matching lines @@
 TEST_F(CCDamageTrackerTest, verifyDamageForSurfaceChangeFromDescendantLayer)
 {
     // If descendant layer changes and affects the content bounds of the render surface,
     // then the entire descendant surface should be damaged, and it should damage its
     // ancestor surface with the old and new surface regions.
 
     // This is a tricky case, since only the first grandChild changes, but the entire
     // surface should be marked dirty.
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* grandChild1 = root->children()[0]->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* grandChild1 = root->children()[0]->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     clearDamageForAllSurfaces(root.get());
     grandChild1->setPosition(FloatPoint(195, 205));
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
 
     // The new surface bounds should be damaged entirely, even though only one of the layers changed.
@@ skipping 11 matching lines @@
     // to the subtree (tested in CCLayerImpltest), which damages the entire child1
     // surface, but the damage tracker still needs the correct logic to compute the
     // exposed region on the root surface.
 
     // FIXME: the expectations of this test case should change when we add support for a
     //        unique scissorRect per renderSurface. In that case, the child1 surface
     //        should be completely unchanged, since we are only transforming it, while the
     //        root surface would be damaged appropriately.
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     clearDamageForAllSurfaces(root.get());
     child1->setPosition(FloatPoint(50, 50));
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
 
     // The new surface bounds should be damaged entirely.
     EXPECT_FLOAT_RECT_EQ(FloatRect(190, 190, 16, 18), childDamageRect);
 
     // The entire child1 surface and the old exposed child1 surface should damage the root surface.
     //  - old child1 surface in target space: FloatRect(290, 290, 16, 18)
     //  - new child1 surface in target space: FloatRect(240, 240, 16, 18)
     EXPECT_FLOAT_RECT_EQ(FloatRect(240, 240, 66, 68), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForAddingAndRemovingRenderSurfaces)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     // CASE 1: If a descendant surface disappears, its entire old area becomes exposed.
     //
     clearDamageForAllSurfaces(root.get());
     child1->setOpacity(1);
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that there is only one surface now.
@@ skipping 23 matching lines @@
 
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(190, 190, 16, 18), childDamageRect);
     EXPECT_FLOAT_RECT_EQ(FloatRect(290, 290, 16, 18), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyNoDamageWhenNothingChanged)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     // CASE 1: If nothing changes, the damage rect should be empty.
     //
     clearDamageForAllSurfaces(root.get());
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(childDamageRect.isEmpty());
     EXPECT_TRUE(rootDamageRect.isEmpty());
 
     // CASE 2: If nothing changes twice in a row, the damage rect should still be empty.
     //
     clearDamageForAllSurfaces(root.get());
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(childDamageRect.isEmpty());
     EXPECT_TRUE(rootDamageRect.isEmpty());
 }
 
 TEST_F(CCDamageTrackerTest, verifyNoDamageForUpdateRectThatDoesNotDrawContent)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
     FloatRect childDamageRect;
     FloatRect rootDamageRect;
 
     // In our specific tree, the update rect of child1 should not cause any damage to any
     // surface because it does not actually draw content.
     clearDamageForAllSurfaces(root.get());
     child1->setUpdateRect(FloatRect(0, 0, 1, 2));
     emulateDrawingOneFrame(root.get());
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(childDamageRect.isEmpty());
     EXPECT_TRUE(rootDamageRect.isEmpty());
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForReplica)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* grandChild1 = child1->children()[0].get();
-    CCLayerImpl* grandChild2 = child1->children()[1].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* grandChild1 = child1->children()[0];
+    CCLayerImpl* grandChild2 = child1->children()[1];
 
     // Damage on a surface that has a reflection should cause the target surface to
     // receive the surface's damage and the surface's reflected damage.
 
     // For this test case, we modify grandChild2, and add grandChild3 to extend the bounds
     // of child1's surface. This way, we can test reflection changes without changing
     // contentBounds of the surface.
     grandChild2->setPosition(FloatPoint(180, 180));
     {
         OwnPtr<CCLayerImpl> grandChild3 = CCLayerImpl::create(6);
@@ skipping 63 matching lines @@
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
 
     EXPECT_FLOAT_RECT_EQ(FloatRect(189, 205, 12, 8), childDamageRect);
     EXPECT_FLOAT_RECT_EQ(FloatRect(289, 305, 12, 8), rootDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForMask)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     // In the current implementation of the damage tracker, changes to mask layers should
     // damage the entire corresponding surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Set up the mask layer.
     {
         OwnPtr<CCLayerImpl> maskLayer = CCLayerImpl::create(3);
         maskLayer->setPosition(child->position());
@@ skipping 63 matching lines @@
     // Sanity check that a render surface still exists.
     ASSERT_TRUE(child->renderSurface());
 
     childDamageRect = child->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 30, 30), childDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForReplicaMask)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* grandChild1 = child1->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* grandChild1 = child1->children()[0];
 
     // Changes to a replica's mask should not damage the original surface, because it is
     // not masked. But it does damage the ancestor target surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Create a reflection about the left edge of grandChild1.
     {
         OwnPtr<CCLayerImpl> grandChild1Replica = CCLayerImpl::create(6);
         grandChild1Replica->setPosition(FloatPoint::zero());
@@ skipping 41 matching lines @@
     grandChildDamageRect = grandChild1->renderSurface()->damageTracker()->currentDamageRect();
     childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
 
     EXPECT_TRUE(grandChildDamageRect.isEmpty());
     EXPECT_FLOAT_RECT_EQ(FloatRect(194, 200, 6, 8), childDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageForReplicaMaskWithAnchor)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
-    CCLayerImpl* child1 = root->children()[0].get();
-    CCLayerImpl* grandChild1 = child1->children()[0].get();
+    CCLayerImpl* child1 = root->children()[0];
+    CCLayerImpl* grandChild1 = child1->children()[0];
 
     // Verify that the correct replicaOriginTransform is used for the replicaMask;
     clearDamageForAllSurfaces(root.get());
 
     grandChild1->setAnchorPoint(FloatPoint(1, 0)); // This is not exactly the anchor being tested, but by convention its expected to be the same as the replica's anchor point.
 
     {
         OwnPtr<CCLayerImpl> grandChild1Replica = CCLayerImpl::create(6);
         grandChild1Replica->setPosition(FloatPoint::zero());
         grandChild1Replica->setAnchorPoint(FloatPoint(1, 0)); // This is the anchor being tested.
@@ skipping 26 matching lines @@
 
     emulateDrawingOneFrame(root.get());
 
     FloatRect childDamageRect = child1->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(206, 200, 6, 8), childDamageRect);
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageWhenForcedFullDamage)
 {
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     // Case 1: This test ensures that when the tracker is forced to have full damage, that
     //         it takes priority over any other partial damage.
     //
     clearDamageForAllSurfaces(root.get());
     child->setUpdateRect(FloatRect(10, 11, 12, 13));
     root->renderSurface()->damageTracker()->forceFullDamageNextUpdate();
     emulateDrawingOneFrame(root.get());
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(0, 0, 500, 500), rootDamageRect);
@@ skipping 23 matching lines @@
 
     FloatRect damageRect = targetSurface->damageTracker()->currentDamageRect();
     EXPECT_TRUE(damageRect.isEmpty());
 }
 
 TEST_F(CCDamageTrackerTest, verifyDamageAccumulatesUntilReset)
 {
     // If damage is not cleared, it should accumulate.
 
     OwnPtr<CCLayerImpl> root = createAndSetUpTestTreeWithOneSurface();
-    CCLayerImpl* child = root->children()[0].get();
+    CCLayerImpl* child = root->children()[0];
 
     clearDamageForAllSurfaces(root.get());
     child->setUpdateRect(FloatRect(10, 11, 1, 2));
     emulateDrawingOneFrame(root.get());
 
     // Sanity check damage after the first frame; this isnt the actual test yet.
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(110, 111, 1, 2), rootDamageRect);
 
     // New damage, without having cleared the previous damage, should be unioned to the previous one.
     child->setUpdateRect(FloatRect(20, 25, 1, 2));
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(110, 111, 11, 16), rootDamageRect);
 
     // If we notify the damage tracker that we drew the damaged area, then damage should be emptied.
     root->renderSurface()->damageTracker()->didDrawDamagedArea();
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.isEmpty());
 
     // Damage should remain empty even after one frame, since there's yet no new damage
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.isEmpty());
 }
 
 } // namespace