cc: Remove OwnPtr usage from CCRenderPass and CCDrawQuad class hierarchy.

cc/CCDrawQuadTest.cpp

 // Copyright 2012 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 "CCDrawQuad.h"
 
 #include "CCCheckerboardDrawQuad.h"
 #include "CCDebugBorderDrawQuad.h"
@@ skipping 16 matching lines @@
 
 TEST(CCDrawQuadTest, copySharedQuadState)
 {
     WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0);
     IntRect visibleContentRect(10, 12, 14, 16);
     IntRect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 0.25;
     bool opaque = true;
     int id = 3;
 
-    OwnPtr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
+    scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
     state->id = id;
 
-    OwnPtr<CCSharedQuadState> copy(state->copy());
+    scoped_ptr<CCSharedQuadState> copy(state->copy());
     EXPECT_EQ(id, copy->id);
     EXPECT_EQ(quadTransform, copy->quadTransform);
     EXPECT_RECT_EQ(visibleContentRect, copy->visibleContentRect);
     EXPECT_RECT_EQ(clippedRectInTarget, copy->clippedRectInTarget);
     EXPECT_EQ(opacity, copy->opacity);
     EXPECT_EQ(opaque, copy->opaque);
 }
 
-PassOwnPtr<CCSharedQuadState> createSharedQuadState()
+scoped_ptr<CCSharedQuadState> createSharedQuadState()
 {
     WebTransformationMatrix quadTransform(1, 0.5, 0, 1, 0.5, 0);
     IntRect visibleContentRect(10, 12, 14, 16);
     IntRect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 1;
     bool opaque = false;
     int id = 3;
 
-    OwnPtr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
+    scoped_ptr<CCSharedQuadState> state(CCSharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity, opaque));
     state->id = id;
-    return state.release();
+    return state.Pass();
 }
 
 void compareDrawQuad(CCDrawQuad* quad, CCDrawQuad* copy, CCSharedQuadState* copySharedState)
 {
     EXPECT_EQ(quad->size(), copy->size());
     EXPECT_EQ(quad->material(), copy->material());
     EXPECT_EQ(quad->isDebugQuad(), copy->isDebugQuad());
     EXPECT_RECT_EQ(quad->quadRect(), copy->quadRect());
     EXPECT_RECT_EQ(quad->quadVisibleRect(), copy->quadVisibleRect());
     EXPECT_EQ(quad->opaqueRect(), copy->opaqueRect());
     EXPECT_EQ(quad->needsBlending(), copy->needsBlending());
 
     EXPECT_EQ(copySharedState, copy->sharedQuadState());
     EXPECT_EQ(copySharedState->id, copy->sharedQuadStateId());
 
     EXPECT_EQ(quad->sharedQuadStateId(), quad->sharedQuadState()->id);
     EXPECT_EQ(copy->sharedQuadStateId(), copy->sharedQuadState()->id);
 }
 
 #define CREATE_SHARED_STATE() \
-    OwnPtr<CCSharedQuadState> sharedState(createSharedQuadState()); \
-    OwnPtr<CCSharedQuadState> copySharedState(sharedState->copy()); \
+    scoped_ptr<CCSharedQuadState> sharedState(createSharedQuadState()); \
+    scoped_ptr<CCSharedQuadState> copySharedState(sharedState->copy()); \
     copySharedState->id = 5;
 
 #define QUAD_DATA \
     IntRect quadRect(30, 40, 50, 60); \
     IntRect quadVisibleRect(40, 50, 30, 20); \
 
 #define SETUP_AND_COPY_QUAD(Type, quad) \
     quad->setQuadVisibleRect(quadVisibleRect); \
-    OwnPtr<CCDrawQuad> copy(quad->copy(copySharedState.get())); \
+    scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get())); \
     compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
     const Type* copyQuad = Type::materialCast(copy.get());
 
 #define SETUP_AND_COPY_QUAD_1(Type, quad, a) \
     quad->setQuadVisibleRect(quadVisibleRect); \
-    OwnPtr<CCDrawQuad> copy(quad->copy(copySharedState.get(), a));    \
+    scoped_ptr<CCDrawQuad> copy(quad->copy(copySharedState.get(), a));    \
     compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
     const Type* copyQuad = Type::materialCast(copy.get());
 
 #define CREATE_QUAD_0(Type) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \
     SETUP_AND_COPY_QUAD(Type, quad); \
     UNUSED_PARAM(copyQuad);
 
 #define CREATE_QUAD_1(Type, a) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_2(Type, a, b) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_3(Type, a, b, c) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_4(Type, a, b, c, d) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_5(Type, a, b, c, d, e) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_6(Type, a, b, c, d, e, f) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_7(Type, a, b, c, d, e, f, g) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_8(Type, a, b, c, d, e, f, g, h) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_8_1(Type, a, b, c, d, e, f, g, h, copyA) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
     SETUP_AND_COPY_QUAD_1(Type, quad, copyA);
 
 #define CREATE_QUAD_9(Type, a, b, c, d, e, f, g, h, i) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 #define CREATE_QUAD_10(Type, a, b, c, d, e, f, g, h, i, j) \
     QUAD_DATA \
-    OwnPtr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i, j)); \
+    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i, j)); \
     SETUP_AND_COPY_QUAD(Type, quad);
 
 TEST(CCDrawQuadTest, copyCheckerboardDrawQuad)
 {
     CREATE_SHARED_STATE();
     CREATE_QUAD_0(CCCheckerboardDrawQuad);
 }
 
 TEST(CCDrawQuadTest, copyDebugBorderDrawQuad)
 {
@@ skipping 133 matching lines @@
     EXPECT_EQ(uPlane.size, copyQuad->uPlane().size);
     EXPECT_EQ(uPlane.format, copyQuad->uPlane().format);
     EXPECT_EQ(uPlane.visibleSize, copyQuad->uPlane().visibleSize);
     EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId);
     EXPECT_EQ(vPlane.size, copyQuad->vPlane().size);
     EXPECT_EQ(vPlane.format, copyQuad->vPlane().format);
     EXPECT_EQ(vPlane.visibleSize, copyQuad->vPlane().visibleSize);
 }
 
 } // namespace