Remove WTF HashMap and PassOwnPtr dependencies for CCRenderPass

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 2512 matching lines @@
         setThumbResourceId(provider->createResource(pool, size, format, hint));
     }
 
 protected:
     explicit FakeScrollbarLayerImpl(int id)
         : CCScrollbarLayerImpl(id)
     {
     }
 };
 
-static inline PassOwnPtr<CCRenderPass> createRenderPassWithResource(CCResourceProvider* provider)
+static inline scoped_ptr<CCRenderPass> createRenderPassWithResource(CCResourceProvider* provider)
 {
     CCResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny);
 
-    OwnPtr<CCRenderPass> pass = CCRenderPass::create(CCRenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
+    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);
 
     static_cast<CCTestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.release());
     static_cast<CCTestRenderPass*>(pass.get())->appendQuad(quad.release());
 
-    return pass.release();
+    return pass.Pass();
 }
 
 TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 {
     int layerId = 1;
 
     OwnPtr<CCLayerImpl> rootLayer(CCLayerImpl::create(layerId++));
     rootLayer->setBounds(IntSize(10, 10));
     rootLayer->setAnchorPoint(FloatPoint(0, 0));
 
@@ skipping 80 matching lines @@
     scrollbarLayer->setDrawsContent(true);
     scrollbarLayer->setLayerTreeHostImpl(m_hostImpl.get());
     scrollbarLayer->createResources(m_hostImpl->resourceProvider());
     rootLayer->addChild(scrollbarLayer.release());
 
     OwnPtr<CCDelegatedRendererLayerImpl> delegatedRendererLayer(CCDelegatedRendererLayerImpl::create(layerId++));
     delegatedRendererLayer->setBounds(IntSize(10, 10));
     delegatedRendererLayer->setContentBounds(IntSize(10, 10));
     delegatedRendererLayer->setDrawsContent(true);
     delegatedRendererLayer->setLayerTreeHostImpl(m_hostImpl.get());
-    OwnPtrVector<CCRenderPass> passList;
+    ScopedPtrVector<CCRenderPass> passList;
     passList.append(createRenderPassWithResource(m_hostImpl->resourceProvider()));
     delegatedRendererLayer->setRenderPasses(passList);
     EXPECT_TRUE(passList.isEmpty());
     rootLayer->addChild(delegatedRendererLayer.release());
 
     // Use a context that supports IOSurfaces
     m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DWithIOSurface)));
 
     hwVideoFrame.setTextureId(m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture());
 
@@ skipping 1260 matching lines @@
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 {
     m_hostImpl->releaseContentsTextures();
     EXPECT_TRUE(m_didRequestCommit);
 }
 
-struct RenderPassCacheEntry {
-    mutable OwnPtr<CCRenderPass> renderPassPtr;
-    CCRenderPass* renderPass;
-
-    RenderPassCacheEntry(PassOwnPtr<CCRenderPass> r)
-        : renderPassPtr(r),
-          renderPass(renderPassPtr.get())
-    {
-    }
-
-    RenderPassCacheEntry()
-    {
-    }
-
-    RenderPassCacheEntry(const RenderPassCacheEntry& entry)
-        : renderPassPtr(entry.renderPassPtr.release()),
-          renderPass(entry.renderPass)
-    {
-    }
-
-    RenderPassCacheEntry& operator=(const RenderPassCacheEntry& entry)
-    {
-        renderPassPtr = entry.renderPassPtr.release();
-        renderPass = entry.renderPass;
-        return *this;
-    }
-};
-
 struct RenderPassRemovalTestData : public CCLayerTreeHostImpl::FrameData {
-    std::map<CCRenderPass::Id, RenderPassCacheEntry> renderPassCache;
+    ScopedPtrHashMap<CCRenderPass::Id, CCRenderPass> renderPassCache;
     OwnPtr<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;
 
         return renderer.release();
     }
 
     void clearCachedTextures() { m_textures.clear(); }
-    void setHaveCachedResourcesForRenderPassId(CCRenderPass::Id id) { m_textures.add(id); }
+    void setHaveCachedResourcesForRenderPassId(CCRenderPass::Id id) { m_textures.insert(id); }
 
-    virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id id) const OVERRIDE { return m_textures.contains(id); }
+    virtual bool haveCachedResourcesForRenderPassId(CCRenderPass::Id id) const OVERRIDE { return m_textures.count(id); }
 
     // CCRendererClient implementation.
     virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
     virtual const CCLayerTreeSettings& settings() const OVERRIDE { return m_settings; }
     virtual void didLoseContext() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { }
     virtual void releaseContentsTextures() OVERRIDE { }
     virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE { }
 
 protected:
     CCTestRenderer(CCResourceProvider* resourceProvider) : CCRendererGL(this, resourceProvider) { }
 
 private:
     CCLayerTreeSettings m_settings;
     IntSize m_viewportSize;
-    HashSet<CCRenderPass::Id> m_textures;
+    base::hash_set<CCRenderPass::Id> m_textures;
 };
 
 static void configureRenderPassTestData(const char* testScript, RenderPassRemovalTestData& testData, CCTestRenderer* renderer)
 {
     renderer->clearCachedTextures();
 
     // One shared state for all quads - we don't need the correct details
     testData.sharedQuadState = CCSharedQuadState::create(WebTransformationMatrix(), IntRect(), IntRect(), 1.0, true);
 
     const char* currentChar = testScript;
 
     // Pre-create root pass
     CCRenderPass::Id rootRenderPassId = CCRenderPass::Id(testScript[0], testScript[1]);
-    OwnPtr<CCRenderPass> rootRenderPass = CCRenderPass::create(rootRenderPassId, IntRect(), WebTransformationMatrix());
-    testData.renderPassCache.insert(std::pair<CCRenderPass::Id, RenderPassCacheEntry>(rootRenderPassId, RenderPassCacheEntry(rootRenderPass.release())));
+    testData.renderPassCache.add(rootRenderPassId, CCRenderPass::create(rootRenderPassId, IntRect(), WebTransformationMatrix()));
     while (*currentChar) {
         int layerId = *currentChar;
         currentChar++;
         ASSERT_TRUE(currentChar);
         int index = *currentChar;
         currentChar++;
 
         CCRenderPass::Id renderPassId = CCRenderPass::Id(layerId, index);
 
-        OwnPtr<CCRenderPass> renderPass;
-
         bool isReplica = false;
-        if (!testData.renderPassCache[renderPassId].renderPassPtr.get())
+        if (!testData.renderPassCache.contains(renderPassId))
             isReplica = true;
 
-        renderPass = testData.renderPassCache[renderPassId].renderPassPtr.release();
+        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);
                 
                 static_cast<CCTestRenderPass*>(renderPass.get())->appendQuad(quad.release());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
@@ skipping 22 matching lines @@
                         currentChar++;
                     }
                     if (*currentChar == ']')
                         currentChar++;
                 }
 
                 if (testData.renderPassCache.find(newRenderPassId) == testData.renderPassCache.end()) {
                     if (hasTexture)
                         renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
 
-                    OwnPtr<CCRenderPass> renderPass = CCTestRenderPass::create(newRenderPassId, IntRect(), WebTransformationMatrix());
-                    testData.renderPassCache.insert(std::pair<CCRenderPass::Id, RenderPassCacheEntry>(newRenderPassId, RenderPassCacheEntry(renderPass.release())));
+                    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());
             }
         }
         testData.renderPasses.insert(0, renderPass.get());
-        testData.renderPassesById.add(renderPassId, renderPass.release());
+        testData.renderPassesById.add(renderPassId, renderPass.Pass());
         if (*currentChar)
             currentChar++;
     }
 }
 
 void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buffer)
 {
     char* pos = buffer;
     for (CCRenderPassList::const_reverse_iterator it = testData.renderPasses.rbegin(); it != testData.renderPasses.rend(); ++it) {
         const CCRenderPass* currentPass = *it;
@@ skipping 190 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