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

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 1391 matching lines @@
     {
         m_quadsAppended = true;
 
         IntRect opaqueRect;
         if (opaque() || m_opaqueContents)
             opaqueRect = m_quadRect;
         else
             opaqueRect = m_opaqueContentRect;
 
         CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-        OwnPtr<CCDrawQuad> testBlendingDrawQuad = CCTileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, IntPoint(), IntSize(1, 1), 0, false, false, false, false, false);
+        scoped_ptr<CCTileDrawQuad> testBlendingDrawQuad = CCTileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, IntPoint(), IntSize(1, 1), 0, false, false, false, false, false);
         testBlendingDrawQuad->setQuadVisibleRect(m_quadVisibleRect);
         EXPECT_EQ(m_blend, testBlendingDrawQuad->needsBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
-        quadSink.append(testBlendingDrawQuad.release(), appendQuadsData);
+        quadSink.append(testBlendingDrawQuad.PassAs<CCDrawQuad>(), appendQuadsData);
     }
 
     void setExpectation(bool blend, bool hasRenderSurface)
     {
         m_blend = blend;
         m_hasRenderSurface = hasRenderSurface;
         m_quadsAppended = false;
     }
 
     bool quadsAppended() const { return m_quadsAppended; }
@@ skipping 504 matching lines @@
 class FakeLayerWithQuads : public CCLayerImpl {
 public:
     static PassOwnPtr<FakeLayerWithQuads> create(int id) { return adoptPtr(new FakeLayerWithQuads(id)); }
 
     virtual void appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData) OVERRIDE
     {
         CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
         IntRect quadRect(IntPoint(0, 0), contentBounds());
-        OwnPtr<CCDrawQuad> myQuad = CCSolidColorDrawQuad::create(sharedQuadState, quadRect, gray);
-        quadSink.append(myQuad.release(), appendQuadsData);
+        scoped_ptr<CCSolidColorDrawQuad> myQuad = CCSolidColorDrawQuad::create(sharedQuadState, quadRect, gray);
+        quadSink.append(myQuad.PassAs<CCDrawQuad>(), appendQuadsData);
     }
 
 private:
     FakeLayerWithQuads(int id)
         : CCLayerImpl(id)
     {
     }
 };
 
 namespace {
@@ skipping 575 matching lines @@
         : CCScrollbarLayerImpl(id)
     {
     }
 };
 
 static inline scoped_ptr<CCRenderPass> createRenderPassWithResource(CCResourceProvider* provider)
 {
     CCResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
 
     scoped_ptr<CCRenderPass> pass = CCRenderPass::create(CCRenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
-    OwnPtr<CCSharedQuadState> sharedState = CCSharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
-    OwnPtr<CCTextureDrawQuad> quad = CCTextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
+    scoped_ptr<CCSharedQuadState> sharedState = CCSharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
+    scoped_ptr<CCTextureDrawQuad> quad = CCTextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
 
-    static_cast<CCTestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.release());
-    static_cast<CCTestRenderPass*>(pass.get())->appendQuad(quad.release());
+    static_cast<CCTestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.Pass());
+    static_cast<CCTestRenderPass*>(pass.get())->appendQuad(quad.PassAs<CCDrawQuad>());
 
     return pass.Pass();
 }
 
 TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(layerId++));
     rootLayer->setBounds(IntSize(10, 10));
@@ skipping 1365 matching lines @@
 }
 
 TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 {
     m_hostImpl->releaseContentsTextures();
     EXPECT_TRUE(m_didRequestCommit);
 }
 
 struct RenderPassRemovalTestData : public CCLayerTreeHostImpl::FrameData {
     ScopedPtrHashMap<CCRenderPass::Id, CCRenderPass> renderPassCache;
-    OwnPtr<CCSharedQuadState> sharedQuadState;
+    scoped_ptr<CCSharedQuadState> sharedQuadState;
 };
 
 class CCTestRenderer : public CCRendererGL, public CCRendererClient {
 public:
     static PassOwnPtr<CCTestRenderer> create(CCResourceProvider* resourceProvider)
     {
         OwnPtr<CCTestRenderer> renderer(adoptPtr(new CCTestRenderer(resourceProvider)));
         if (!renderer->initialize())
             return nullptr;
 
@@ skipping 47 matching lines @@
         bool isReplica = false;
         if (!testData.renderPassCache.contains(renderPassId))
             isReplica = true;
 
         scoped_ptr<CCRenderPass> renderPass = testData.renderPassCache.take(renderPassId);
 
         // Cycle through quad data and create all quads
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
-                OwnPtr<CCDrawQuad> quad = CCSolidColorDrawQuad::create(testData.sharedQuadState.get(), IntRect(0, 0, 10, 10), SK_ColorWHITE);
+                scoped_ptr<CCSolidColorDrawQuad> quad = CCSolidColorDrawQuad::create(testData.sharedQuadState.get(), IntRect(0, 0, 10, 10), SK_ColorWHITE);
                 
-                static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.release());
+                static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.PassAs<CCDrawQuad>());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
                 // RenderPass draw quad
                 int layerId = *currentChar;
                 currentChar++;
                 ASSERT_TRUE(currentChar);
                 int index = *currentChar;
                 currentChar++;
                 CCRenderPass::Id newRenderPassId = CCRenderPass::Id(layerId, index);
                 ASSERT_NE(rootRenderPassId, newRenderPassId);
@@ skipping 19 matching lines @@
 
                 if (testData.renderPassCache.find(newRenderPassId) == testData.renderPassCache.end()) {
                     if (hasTexture)
                         renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
 
                     testData.renderPassCache.add(newRenderPassId, CCTestRenderPass::create(newRenderPassId, IntRect(), WebTransformationMatrix()));
                 }
 
                 IntRect quadRect = IntRect(0, 0, 1, 1);
                 IntRect contentsChangedRect = contentsChanged ? quadRect : IntRect();
-                OwnPtr<CCRenderPassDrawQuad> quad = CCRenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
-                static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.release());
+                scoped_ptr<CCRenderPassDrawQuad> quad = CCRenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
+                static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.PassAs<CCDrawQuad>());
             }
         }
         testData.renderPasses.insert(0, renderPass.get());
         testData.renderPassesById.add(renderPassId, renderPass.Pass());
         if (*currentChar)
             currentChar++;
     }
 }
 
 void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buffer)
@@ skipping 194 matching lines @@
     while (removeRenderPassesCases[testCaseIndex].name) {
         RenderPassRemovalTestData testData;
         configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
         CCLayerTreeHostImpl::removeRenderPasses(CCLayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), testData);
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 } // namespace