Remove WTF HashMap and PassOwnPtr dependencies for CCRenderPass

We add a ScopedPtrHashMap and ScopedPtrVector which preserve the behaviour
of HashMap<T, OwnPtr<V> > and Vector<OwnPtr<T>> and use these for CCRenderPass
and any code that creates CCRenderPass objects.

R=enne,jamesr
BUG=152049


Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=158729

Review URL: https://chromiumcodereview.appspot.com/10979010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@158837 0039d316-1c4b-4281-b951-d872f2087c98

19 files changed, 344 insertions, 141 deletions

diff --git a/cc/CCDelegatedRendererLayerImpl.cpp b/cc/CCDelegatedRendererLayerImpl.cpp
index d6574ec..237f01f 100644
--- a/cc/CCDelegatedRendererLayerImpl.cpp
+++ b/cc/CCDelegatedRendererLayerImpl.cpp
@@ -41,7 +41,7 @@ bool CCDelegatedRendererLayerImpl::hasContributingDelegatedRenderPasses() const
     return m_renderPassesInDrawOrder.size() > 1;
 }
 
-void CCDelegatedRendererLayerImpl::setRenderPasses(OwnPtrVector<CCRenderPass>& renderPassesInDrawOrder)
+void CCDelegatedRendererLayerImpl::setRenderPasses(ScopedPtrVector<CCRenderPass>& renderPassesInDrawOrder)
 {
     FloatRect oldRootDamage;
     if (!m_renderPassesInDrawOrder.isEmpty())
@@ -50,7 +50,7 @@ void CCDelegatedRendererLayerImpl::setRenderPasses(OwnPtrVector<CCRenderPass>& r
     clearRenderPasses();
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
-        m_renderPassesIndexById.set(renderPassesInDrawOrder[i]->id(), i);
+        m_renderPassesIndexById.insert(std::pair<CCRenderPass::Id, int>(renderPassesInDrawOrder[i]->id(), i));
         m_renderPassesInDrawOrder.append(renderPassesInDrawOrder.take(i));
     }
     renderPassesInDrawOrder.clear();
@@ -88,7 +88,9 @@ CCRenderPass::Id CCDelegatedRendererLayerImpl::nextContributingRenderPassId(CCRe
 
 CCRenderPass::Id CCDelegatedRendererLayerImpl::convertDelegatedRenderPassId(CCRenderPass::Id delegatedRenderPassId) const
 {
-    unsigned delegatedRenderPassIndex = m_renderPassesIndexById.get(delegatedRenderPassId);
+    base::hash_map<CCRenderPass::Id, int>::const_iterator it = m_renderPassesIndexById.find(delegatedRenderPassId);
+    ASSERT(it != m_renderPassesIndexById.end());
+    unsigned delegatedRenderPassIndex = it->second;
     return CCRenderPass::Id(id(), indexToId(delegatedRenderPassIndex));
 }
 
diff --git a/cc/CCDelegatedRendererLayerImpl.h b/cc/CCDelegatedRendererLayerImpl.h
index 9e197c8..7203faf 100644
--- a/cc/CCDelegatedRendererLayerImpl.h
+++ b/cc/CCDelegatedRendererLayerImpl.h
@@ -6,6 +6,7 @@
 #define CCDelegatedRendererLayerImpl_h
 
 #include "CCLayerImpl.h"
+#include "cc/scoped_ptr_vector.h"
 
 namespace cc {
 
@@ -18,7 +19,7 @@ public:
     virtual bool hasContributingDelegatedRenderPasses() const OVERRIDE;
 
     // This gives ownership of the RenderPasses to the layer.
-    void setRenderPasses(OwnPtrVector<CCRenderPass>&);
+    void setRenderPasses(ScopedPtrVector<CCRenderPass>&);
     void clearRenderPasses();
 
     virtual void didLoseContext() OVERRIDE;
@@ -40,8 +41,8 @@ private:
 
     virtual const char* layerTypeAsString() const OVERRIDE;
 
-    OwnPtrVector<CCRenderPass> m_renderPassesInDrawOrder;
-    HashMap<CCRenderPass::Id, int> m_renderPassesIndexById;
+    ScopedPtrVector<CCRenderPass> m_renderPassesInDrawOrder;
+    base::hash_map<CCRenderPass::Id, int> m_renderPassesIndexById;
 };
 
 }
diff --git a/cc/CCDelegatedRendererLayerImplTest.cpp b/cc/CCDelegatedRendererLayerImplTest.cpp
index 71e1a0e..465bcac 100644
--- a/cc/CCDelegatedRendererLayerImplTest.cpp
+++ b/cc/CCDelegatedRendererLayerImplTest.cpp
@@ -18,6 +18,7 @@
 #include "FakeWebCompositorOutputSurface.h"
 #include "FakeWebGraphicsContext3D.h"
 #include "MockCCQuadCuller.h"
+#include "cc/scoped_ptr_vector.h"
 #include <gtest/gtest.h>
 #include <public/WebTransformationMatrix.h>
 
@@ -64,11 +65,11 @@ protected:
     OwnPtr<CCLayerTreeHostImpl> m_hostImpl;
 };
 
-static CCTestRenderPass* addRenderPass(OwnPtrVector<CCRenderPass>& passList, CCRenderPass::Id id, IntRect outputRect, WebTransformationMatrix rootTransform)
+static CCTestRenderPass* addRenderPass(ScopedPtrVector<CCRenderPass>& passList, CCRenderPass::Id id, IntRect outputRect, WebTransformationMatrix rootTransform)
 {
-    OwnPtr<CCRenderPass> pass(CCRenderPass::create(id, outputRect, rootTransform));
+    scoped_ptr<CCRenderPass> pass(CCRenderPass::create(id, outputRect, rootTransform));
     CCTestRenderPass* testPass = static_cast<CCTestRenderPass*>(pass.get());
-    passList.append(pass.release());
+    passList.append(pass.Pass());
     return testPass;
 }
 
@@ -126,7 +127,7 @@ public:
         transform.translate(1, 1);
         delegatedRendererLayer->setTransform(transform);
 
-        OwnPtrVector<CCRenderPass> delegatedRenderPasses;
+        ScopedPtrVector<CCRenderPass> delegatedRenderPasses;
         CCTestRenderPass* pass1 = addRenderPass(delegatedRenderPasses, CCRenderPass::Id(9, 6), IntRect(6, 6, 6, 6), WebTransformationMatrix());
         addQuad(pass1, IntRect(0, 0, 6, 6), 33u);
         CCTestRenderPass* pass2 = addRenderPass(delegatedRenderPasses, CCRenderPass::Id(9, 7), IntRect(7, 7, 7, 7), WebTransformationMatrix());
diff --git a/cc/CCDirectRenderer.cpp b/cc/CCDirectRenderer.cpp
index 1e9df5d..8bf3c4b 100644
--- a/cc/CCDirectRenderer.cpp
+++ b/cc/CCDirectRenderer.cpp
@@ -8,6 +8,7 @@
 
 #include "CCMathUtil.h"
 #include <public/WebTransformationMatrix.h>
+#include <vector>
 
 using WebKit::WebTransformationMatrix;
 
@@ -114,34 +115,23 @@ CCDirectRenderer::~CCDirectRenderer()
 
 void CCDirectRenderer::decideRenderPassAllocationsForFrame(const CCRenderPassList& renderPassesInDrawOrder)
 {
-    HashMap<CCRenderPass::Id, const CCRenderPass*> renderPassesInFrame;
+    base::hash_map<CCRenderPass::Id, const CCRenderPass*> renderPassesInFrame;
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i)
-        renderPassesInFrame.set(renderPassesInDrawOrder[i]->id(), renderPassesInDrawOrder[i]);
+        renderPassesInFrame.insert(std::pair<CCRenderPass::Id, const CCRenderPass*>(renderPassesInDrawOrder[i]->id(), renderPassesInDrawOrder[i]));
 
-    Vector<CCRenderPass::Id> passesToDelete;
-    HashMap<CCRenderPass::Id, OwnPtr<CachedTexture> >::const_iterator passIterator;
+    std::vector<CCRenderPass::Id> passesToDelete;
+    ScopedPtrHashMap<CCRenderPass::Id, CachedTexture>::const_iterator passIterator;
     for (passIterator = m_renderPassTextures.begin(); passIterator != m_renderPassTextures.end(); ++passIterator) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        const CCRenderPass* renderPassInFrame = renderPassesInFrame.get(passIterator->key);
-#else
-        const CCRenderPass* renderPassInFrame = renderPassesInFrame.get(passIterator->first);
-#endif
-        if (!renderPassInFrame) {
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-            passesToDelete.append(passIterator->key);
-#else
-            passesToDelete.append(passIterator->first);
-#endif
+        base::hash_map<CCRenderPass::Id, const CCRenderPass*>::const_iterator it = renderPassesInFrame.find(passIterator->first);
+        if (it == renderPassesInFrame.end()) {
+            passesToDelete.push_back(passIterator->first);
             continue;
         }
 
+        const CCRenderPass* renderPassInFrame = it->second;
         const IntSize& requiredSize = renderPassTextureSize(renderPassInFrame);
         GC3Denum requiredFormat = renderPassTextureFormat(renderPassInFrame);
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-        CachedTexture* texture = passIterator->value.get();
-#else
-        CachedTexture* texture = passIterator->second.get();
-#endif
+        CachedTexture* texture = passIterator->second;
         ASSERT(texture);
 
         if (texture->id() && (texture->size() != requiredSize || texture->format() != requiredFormat))
@@ -150,12 +140,12 @@ void CCDirectRenderer::decideRenderPassAllocationsForFrame(const CCRenderPassLis
 
     // Delete RenderPass textures from the previous frame that will not be used again.
     for (size_t i = 0; i < passesToDelete.size(); ++i)
-        m_renderPassTextures.remove(passesToDelete[i]);
+        m_renderPassTextures.erase(passesToDelete[i]);
 
     for (size_t i = 0; i < renderPassesInDrawOrder.size(); ++i) {
         if (!m_renderPassTextures.contains(renderPassesInDrawOrder[i]->id())) {
-            OwnPtr<CachedTexture> texture = CachedTexture::create(m_resourceProvider);
-            m_renderPassTextures.set(renderPassesInDrawOrder[i]->id(), texture.release());
+          scoped_ptr<CachedTexture> texture = CachedTexture::create(m_resourceProvider);
+            m_renderPassTextures.set(renderPassesInDrawOrder[i]->id(), texture.Pass());
         }
     }
 }
diff --git a/cc/CCDirectRenderer.h b/cc/CCDirectRenderer.h
index e11d1d74..b9db57e 100644
--- a/cc/CCDirectRenderer.h
+++ b/cc/CCDirectRenderer.h
@@ -50,7 +50,7 @@ protected:
     class CachedTexture : public CCScopedTexture {
         WTF_MAKE_NONCOPYABLE(CachedTexture);
     public:
-        static PassOwnPtr<CachedTexture> create(CCResourceProvider* resourceProvider) { return adoptPtr(new CachedTexture(resourceProvider)); }
+        static scoped_ptr<CachedTexture> create(CCResourceProvider* resourceProvider) { return scoped_ptr<CachedTexture>(new CachedTexture(resourceProvider)); }
         virtual ~CachedTexture() { }
 
         bool isComplete() const { return m_isComplete; }
@@ -90,7 +90,7 @@ protected:
     virtual void finishDrawingFrame(DrawingFrame&) = 0;
     virtual bool flippedFramebuffer() const = 0;
 
-    HashMap<CCRenderPass::Id, OwnPtr<CachedTexture> > m_renderPassTextures;
+    ScopedPtrHashMap<CCRenderPass::Id, CachedTexture> m_renderPassTextures;
     CCResourceProvider* m_resourceProvider;
 };
 
diff --git a/cc/CCLayerTreeHostImpl.cpp b/cc/CCLayerTreeHostImpl.cpp
index 504e50b..93c9dd3 100644
--- a/cc/CCLayerTreeHostImpl.cpp
+++ b/cc/CCLayerTreeHostImpl.cpp
@@ -249,11 +249,11 @@ void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSur
     }
 }
 
-void CCLayerTreeHostImpl::FrameData::appendRenderPass(PassOwnPtr<CCRenderPass> renderPass)
+void CCLayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<CCRenderPass> renderPass)
 {
     CCRenderPass* pass = renderPass.get();
     renderPasses.append(pass);
-    renderPassesById.set(pass->id(), renderPass);
+    renderPassesById.set(pass->id(), renderPass.Pass());
 }
 
 bool CCLayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
@@ -407,11 +407,7 @@ static inline CCRenderPass* findRenderPassById(CCRenderPass::Id renderPassId, co
 {
     CCRenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
     ASSERT(it != frame.renderPassesById.end());
-#if WTF_NEW_HASHMAP_ITERATORS_INTERFACE
-    return it->value.get();
-#else
-    return it->second.get();
-#endif
+    return it->second;
 }
 
 static void removeRenderPassesRecursive(CCRenderPass::Id removeRenderPassId, CCLayerTreeHostImpl::FrameData& frame)
diff --git a/cc/CCLayerTreeHostImpl.h b/cc/CCLayerTreeHostImpl.h
index 015281a..a0c9135 100644
--- a/cc/CCLayerTreeHostImpl.h
+++ b/cc/CCLayerTreeHostImpl.h
@@ -76,7 +76,7 @@ public:
         CCLayerList willDrawLayers;
 
         // CCRenderPassSink implementation.
-        virtual void appendRenderPass(PassOwnPtr<CCRenderPass>) OVERRIDE;
+        virtual void appendRenderPass(scoped_ptr<CCRenderPass>) OVERRIDE;
     };
 
     // Virtual for testing.
diff --git a/cc/CCLayerTreeHostImplTest.cpp b/cc/CCLayerTreeHostImplTest.cpp
index 77ac46e..0af69ba 100644
--- a/cc/CCLayerTreeHostImplTest.cpp
+++ b/cc/CCLayerTreeHostImplTest.cpp
@@ -2530,18 +2530,18 @@ protected:
     }
 };
 
-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)
@@ -2642,7 +2642,7 @@ TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
     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());
@@ -3923,36 +3923,8 @@ TEST_F(CCLayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
     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;
 };
 
@@ -3968,9 +3940,9 @@ public:
     }
 
     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; }
@@ -3987,7 +3959,7 @@ protected:
 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)
@@ -4001,8 +3973,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
 
     // 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++;
@@ -4012,13 +3983,11 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
 
         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') {
@@ -4061,8 +4030,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
                     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);
@@ -4072,7 +4040,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
             }
         }
         testData.renderPasses.insert(0, renderPass.get());
-        testData.renderPassesById.add(renderPassId, renderPass.release());
+        testData.renderPassesById.add(renderPassId, renderPass.Pass());
         if (*currentChar)
             currentChar++;
     }
diff --git a/cc/CCRenderPass.cpp b/cc/CCRenderPass.cpp
index 3d67843..acc6483 100644
--- a/cc/CCRenderPass.cpp
+++ b/cc/CCRenderPass.cpp
@@ -17,9 +17,9 @@ using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
-PassOwnPtr<CCRenderPass> CCRenderPass::create(Id id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
+scoped_ptr<CCRenderPass> CCRenderPass::create(Id id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
 {
-    return adoptPtr(new CCRenderPass(id, outputRect, transformToRootTarget));
+    return scoped_ptr<CCRenderPass>(new CCRenderPass(id, outputRect, transformToRootTarget));
 }
 
 CCRenderPass::CCRenderPass(Id id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
@@ -37,17 +37,17 @@ CCRenderPass::~CCRenderPass()
 {
 }
 
-PassOwnPtr<CCRenderPass> CCRenderPass::copy(Id newId) const
+scoped_ptr<CCRenderPass> CCRenderPass::copy(Id newId) const
 {
     ASSERT(newId != m_id);
 
-    OwnPtr<CCRenderPass> copyPass(create(newId, m_outputRect, m_transformToRootTarget));
+    scoped_ptr<CCRenderPass> copyPass(create(newId, m_outputRect, m_transformToRootTarget));
     copyPass->setDamageRect(m_damageRect);
     copyPass->setHasTransparentBackground(m_hasTransparentBackground);
     copyPass->setHasOcclusionFromOutsideTargetSurface(m_hasOcclusionFromOutsideTargetSurface);
     copyPass->setFilters(m_filters);
     copyPass->setBackgroundFilters(m_backgroundFilters);
-    return copyPass.release();
+    return copyPass.Pass();
 }
 
 void CCRenderPass::appendQuadsForLayer(CCLayerImpl* layer, CCOcclusionTrackerImpl* occlusionTracker, CCAppendQuadsData& appendQuadsData)
diff --git a/cc/CCRenderPass.h b/cc/CCRenderPass.h
index d4c518a..4cafa61 100644
--- a/cc/CCRenderPass.h
+++ b/cc/CCRenderPass.h
@@ -10,11 +10,11 @@
 #include "CCSharedQuadState.h"
 #include "FloatRect.h"
 #include "SkColor.h"
+#include "cc/hash_pair.h"
 #include "cc/own_ptr_vector.h"
+#include "cc/scoped_ptr_hash_map.h"
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
-#include <wtf/HashMap.h>
-#include <wtf/PassOwnPtr.h>
 #include <wtf/Vector.h>
 
 namespace cc {
@@ -58,10 +58,10 @@ public:
         bool operator<(const Id& other) const { return layerId < other.layerId || (layerId == other.layerId && index < other.index); }
     };
 
-    static PassOwnPtr<CCRenderPass> create(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
+    static scoped_ptr<CCRenderPass> create(Id, IntRect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget);
 
     // A shallow copy of the render pass, which does not include its quads.
-    PassOwnPtr<CCRenderPass> copy(Id newId) const;
+    scoped_ptr<CCRenderPass> copy(Id newId) const;
 
     void appendQuadsForLayer(CCLayerImpl*, CCOcclusionTrackerImpl*, CCAppendQuadsData&);
     void appendQuadsForRenderSurfaceLayer(CCLayerImpl*, const CCRenderPass* contributingRenderPass, CCOcclusionTrackerImpl*, CCAppendQuadsData&);
@@ -109,27 +109,27 @@ protected:
 
 } // namespace cc
 
-namespace WTF {
-template<> struct HashTraits<cc::CCRenderPass::Id> : GenericHashTraits<cc::CCRenderPass::Id> {
-    static const bool emptyValueIsZero = false;
-    static const bool needsDestruction = false;
-    static cc::CCRenderPass::Id emptyValue() { return cc::CCRenderPass::Id(0, 0); }
-    static void constructDeletedValue(cc::CCRenderPass::Id& slot) { slot = cc::CCRenderPass::Id(-1, -1); }
-    static bool isDeletedValue(cc::CCRenderPass::Id value) { return value.layerId == -1 && value.index == -1; }
+namespace BASE_HASH_NAMESPACE {
+#if defined(COMPILER_MSVC)
+template<>
+inline size_t hash_value<cc::CCRenderPass::Id>(const cc::CCRenderPass::Id& key) {
+    return hash_value<std::pair<int, int> >(std::pair<int, int>(key.layerId, key.index));
+}
+#elif defined(COMPILER_GCC)
+template<>
+struct hash<cc::CCRenderPass::Id> {
+    size_t operator()(cc::CCRenderPass::Id key) const {
+        return hash<std::pair<int, int> >()(std::pair<int, int>(key.layerId, key.index));
+    }
 };
-template<> struct IntHash<cc::CCRenderPass::Id> {
-    static unsigned hash(const cc::CCRenderPass::Id& key) { return PairHash<int, int>::hash(std::make_pair(key.layerId, key.index)); }
-    static bool equal(const cc::CCRenderPass::Id& a, const cc::CCRenderPass::Id& b) { return a == b; }
-    static const bool safeToCompareToEmptyOrDeleted = true;
-};
-template<> struct DefaultHash<cc::CCRenderPass::Id> {
-    typedef IntHash<cc::CCRenderPass::Id> Hash;
-};
-} // namespace WTF
+#else
+#error define a hash function for your compiler
+#endif // COMPILER
+}
 
 namespace cc {
 typedef Vector<CCRenderPass*> CCRenderPassList;
-typedef HashMap<CCRenderPass::Id, OwnPtr<CCRenderPass> > CCRenderPassIdHashMap;
+typedef ScopedPtrHashMap<CCRenderPass::Id, CCRenderPass> CCRenderPassIdHashMap;
 } // namespace cc
 
 #endif
diff --git a/cc/CCRenderPassSink.h b/cc/CCRenderPassSink.h
index 83df154..f3bac1d 100644
--- a/cc/CCRenderPassSink.h
+++ b/cc/CCRenderPassSink.h
@@ -5,7 +5,7 @@
 #ifndef CCRenderPassSink_h
 #define CCRenderPassSink_h
 
-#include <wtf/PassOwnPtr.h>
+#include "base/memory/scoped_ptr.h"
 
 namespace cc {
 
@@ -13,7 +13,7 @@ class CCRenderPass;
 
 class CCRenderPassSink {
 public:
-    virtual void appendRenderPass(PassOwnPtr<CCRenderPass>) = 0;
+    virtual void appendRenderPass(scoped_ptr<CCRenderPass>) = 0;
 };
 
 }
diff --git a/cc/CCRenderPassTest.cpp b/cc/CCRenderPassTest.cpp
index 0d5bad4..23376ec 100644
--- a/cc/CCRenderPassTest.cpp
+++ b/cc/CCRenderPassTest.cpp
@@ -46,7 +46,7 @@ TEST(CCRenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
     IntRect outputRect(45, 22, 120, 13);
     WebTransformationMatrix transformToRoot(1, 0.5, 0.5, -0.5, -1, 0);
 
-    OwnPtr<CCRenderPass> pass(CCRenderPass::create(id, outputRect, transformToRoot));
+    scoped_ptr<CCRenderPass> pass = CCRenderPass::create(id, outputRect, transformToRoot);
 
     IntRect damageRect(56, 123, 19, 43);
     bool hasTransparentBackground = true;
@@ -70,7 +70,7 @@ TEST(CCRenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
 
     CCRenderPass::Id newId(63, 4);
 
-    OwnPtr<CCRenderPass> copy(pass->copy(newId));
+    scoped_ptr<CCRenderPass> copy = pass->copy(newId);
     EXPECT_EQ(newId, copy->id());
     EXPECT_RECT_EQ(pass->outputRect(), copy->outputRect());
     EXPECT_EQ(pass->transformToRootTarget(), copy->transformToRootTarget());
diff --git a/cc/CCRenderSurface.cpp b/cc/CCRenderSurface.cpp
index f4e1d8d..0e66c11 100644
--- a/cc/CCRenderSurface.cpp
+++ b/cc/CCRenderSurface.cpp
@@ -191,11 +191,11 @@ void CCRenderSurface::appendRenderPasses(CCRenderPassSink& passSink)
     for (size_t i = 0; i < m_contributingDelegatedRenderPassLayerList.size(); ++i)
         m_contributingDelegatedRenderPassLayerList[i]->appendContributingRenderPasses(passSink);
 
-    OwnPtr<CCRenderPass> pass = CCRenderPass::create(renderPassId(), m_contentRect, m_screenSpaceTransform);
+    scoped_ptr<CCRenderPass> pass = CCRenderPass::create(renderPassId(), m_contentRect, m_screenSpaceTransform);
     pass->setDamageRect(m_damageTracker->currentDamageRect());
     pass->setFilters(m_owningLayer->filters());
     pass->setBackgroundFilters(m_owningLayer->backgroundFilters());
-    passSink.appendRenderPass(pass.release());
+    passSink.appendRenderPass(pass.Pass());
 }
 
 void CCRenderSurface::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData, bool forReplica, CCRenderPass::Id renderPassId)
diff --git a/cc/CCRenderSurfaceTest.cpp b/cc/CCRenderSurfaceTest.cpp
index 65c8785..cbba891 100644
--- a/cc/CCRenderSurfaceTest.cpp
+++ b/cc/CCRenderSurfaceTest.cpp
@@ -13,6 +13,7 @@
 #include "CCSingleThreadProxy.h"
 #include "MockCCQuadCuller.h"
 #include "cc/own_ptr_vector.h"
+#include "cc/scoped_ptr_vector.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <public/WebTransformationMatrix.h>
@@ -119,13 +120,12 @@ TEST(CCRenderSurfaceTest, sanityCheckSurfaceCreatesCorrectSharedQuadState)
 
 class TestCCRenderPassSink : public CCRenderPassSink {
 public:
-    virtual void appendRenderPass(PassOwnPtr<CCRenderPass> renderPass) OVERRIDE { m_renderPasses.append(renderPass); }
+    virtual void appendRenderPass(scoped_ptr<CCRenderPass> renderPass) OVERRIDE { m_renderPasses.append(renderPass.Pass()); }
 
-    const OwnPtrVector<CCRenderPass>& renderPasses() const { return m_renderPasses; }
+    const ScopedPtrVector<CCRenderPass>& renderPasses() const { return m_renderPasses; }
 
 private:
-    OwnPtrVector<CCRenderPass> m_renderPasses;
-
+    ScopedPtrVector<CCRenderPass> m_renderPasses;
 };
 
 TEST(CCRenderSurfaceTest, sanityCheckSurfaceCreatesCorrectRenderPass)
diff --git a/cc/CCRendererGLTest.cpp b/cc/CCRendererGLTest.cpp
index f3a1f0e..0f8ba3c 100644
--- a/cc/CCRendererGLTest.cpp
+++ b/cc/CCRendererGLTest.cpp
@@ -63,9 +63,9 @@ public:
     {
         m_rootLayer->createRenderSurface();
         CCRenderPass::Id renderPassId = m_rootLayer->renderSurface()->renderPassId();
-        OwnPtr<CCRenderPass> rootRenderPass = CCRenderPass::create(renderPassId, IntRect(), WebTransformationMatrix());
+        scoped_ptr<CCRenderPass> rootRenderPass = CCRenderPass::create(renderPassId, IntRect(), WebTransformationMatrix());
         m_renderPassesInDrawOrder.append(rootRenderPass.get());
-        m_renderPasses.set(renderPassId, rootRenderPass.release());
+        m_renderPasses.set(renderPassId, rootRenderPass.Pass());
     }
 
     // CCRendererClient methods.
diff --git a/cc/CCRendererSoftwareTest.cpp b/cc/CCRendererSoftwareTest.cpp
index fee24cd..91a131f 100644
--- a/cc/CCRendererSoftwareTest.cpp
+++ b/cc/CCRendererSoftwareTest.cpp
@@ -11,6 +11,7 @@
 #include "CCQuadSink.h"
 #include "CCRenderPass.h"
 #include "CCRenderPassDrawQuad.h"
+#include "CCRenderPassTestCommon.h"
 #include "CCSettings.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
 #include "CCSolidColorDrawQuad.h"
@@ -61,17 +62,6 @@ protected:
     CCLayerTreeSettings m_settings;
 };
 
-class CCTestRenderPass : public CCRenderPass {
-public:
-    static PassOwnPtr<CCTestRenderPass> create(CCRenderPass::Id id, IntRect outputRect, const WebTransformationMatrix& rootTransform) { return adoptPtr(new CCTestRenderPass(id, outputRect, rootTransform)); }
-
-    void appendQuad(PassOwnPtr<CCDrawQuad> quad) { m_quadList.append(quad); }
-
-protected:
-    CCTestRenderPass(CCRenderPass::Id id, IntRect outputRect, const WebTransformationMatrix& rootTransform) : CCRenderPass(id, outputRect, rootTransform) { }
-};
-
-
 TEST_F(CCRendererSoftwareTest, solidColorQuad)
 {
     IntSize outerSize(100, 100);
@@ -85,7 +75,7 @@ TEST_F(CCRendererSoftwareTest, solidColorQuad)
 
     OwnPtr<CCSharedQuadState> sharedQuadState = CCSharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0, true);
     CCRenderPass::Id rootRenderPassId = CCRenderPass::Id(1, 1);
-    OwnPtr<CCRenderPass> rootRenderPass = CCTestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
+    scoped_ptr<CCRenderPass> rootRenderPass = CCTestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
     CCTestRenderPass* testRenderPass = static_cast<CCTestRenderPass*>(rootRenderPass.get());
     OwnPtr<CCDrawQuad> outerQuad = CCSolidColorDrawQuad::create(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
     OwnPtr<CCDrawQuad> innerQuad = CCSolidColorDrawQuad::create(sharedQuadState.get(), innerRect, SK_ColorCYAN);
@@ -95,7 +85,7 @@ TEST_F(CCRendererSoftwareTest, solidColorQuad)
     CCRenderPassList list;
     CCRenderPassIdHashMap hashmap;
     list.append(rootRenderPass.get());
-    hashmap.add(rootRenderPassId, rootRenderPass.release());
+    hashmap.add(rootRenderPassId, rootRenderPass.Pass());
     renderer()->drawFrame(list, hashmap);
 
     OwnArrayPtr<SkColor> pixels = adoptArrayPtr(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
@@ -137,7 +127,7 @@ TEST_F(CCRendererSoftwareTest, tileQuad)
 
     OwnPtr<CCSharedQuadState> sharedQuadState = CCSharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0, true);
     CCRenderPass::Id rootRenderPassId = CCRenderPass::Id(1, 1);
-    OwnPtr<CCRenderPass> rootRenderPass = CCTestRenderPass::create(rootRenderPassId, IntRect(IntPoint(), deviceViewportSize()), WebTransformationMatrix());
+    scoped_ptr<CCRenderPass> rootRenderPass = CCTestRenderPass::create(rootRenderPassId, IntRect(IntPoint(), deviceViewportSize()), WebTransformationMatrix());
     CCTestRenderPass* testRenderPass = static_cast<CCTestRenderPass*>(rootRenderPass.get());
     OwnPtr<CCDrawQuad> outerQuad = CCTileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, IntPoint(), outerSize, 0, false, false, false, false, false);
     OwnPtr<CCDrawQuad> innerQuad = CCTileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, IntPoint(), innerSize, 0, false, false, false, false, false);
@@ -147,7 +137,7 @@ TEST_F(CCRendererSoftwareTest, tileQuad)
     CCRenderPassList list;
     CCRenderPassIdHashMap hashmap;
     list.append(rootRenderPass.get());
-    hashmap.add(rootRenderPassId, rootRenderPass.release());
+    hashmap.add(rootRenderPassId, rootRenderPass.Pass());
     renderer()->drawFrame(list, hashmap);
 
     OwnArrayPtr<SkColor> pixels = adoptArrayPtr(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
diff --git a/cc/cc.gyp b/cc/cc.gyp
index baed1db..319a4ef 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -8,6 +8,9 @@
     'use_libcc_for_compositor%': 0,
     'cc_source_files': [
       'hash_pair.h',
+      'own_ptr_vector.h',
+      'scoped_ptr_hash_map.h',
+      'scoped_ptr_vector.h',
       'BitmapCanvasLayerTextureUpdater.cpp',
       'BitmapCanvasLayerTextureUpdater.h',
       'BitmapSkPictureCanvasLayerTextureUpdater.cpp',
diff --git a/cc/scoped_ptr_hash_map.h b/cc/scoped_ptr_hash_map.h
new file mode 100644
index 0000000..1cea5c0
--- /dev/null
+++ b/cc/scoped_ptr_hash_map.h
@@ -0,0 +1,152 @@
+// 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.
+
+#ifndef CC_SCOPED_PTR_HASH_MAP_H_
+#define CC_SCOPED_PTR_HASH_MAP_H_
+
+#include "base/basictypes.h"
+#include "base/hash_tables.h"
+#include "base/stl_util.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace cc {
+
+// This type acts like a hash_map<K, scoped_ptr<V> >, based on top of
+// std::hash_map. The ScopedPtrHashMap has ownership of all values in the data
+// structure.
+template <typename Key, typename Value>
+class ScopedPtrHashMap {
+  typedef base::hash_map<Key, Value*> Container;
+ public:
+  typedef typename Container::iterator iterator;
+  typedef typename Container::const_iterator const_iterator;
+
+  ScopedPtrHashMap() {}
+
+  ~ScopedPtrHashMap() { clear(); }
+
+  void swap(ScopedPtrHashMap<Key, Value*>& other) {
+    data_.swap(other.data_);
+  }
+
+  std::pair<iterator, bool> insert(
+      std::pair<Key, const scoped_ptr<Value> > pair) {
+    return data_.insert(
+        std::pair<Key, Value*>(pair.first, pair.second.release()));
+  }
+
+  // Replaces value but not key if key is already present.
+  std::pair<iterator, bool> set(Key key, scoped_ptr<Value> data) {
+    iterator it = find(key);
+    if (it != end())
+      erase(it);
+    Value* rawPtr = data.release();
+    return data_.insert(std::pair<Key, Value*>(key, rawPtr));
+  }
+
+  // Does nothing if key is already present
+  std::pair<iterator, bool> add(Key key, scoped_ptr<Value> data) {
+    Value* rawPtr = data.release();
+    return data_.insert(std::pair<Key, Value*>(key, rawPtr));
+  }
+
+  void erase(iterator it) {
+    if (it->second)
+      delete it->second;
+    data_.erase(it);
+  }
+
+  size_t erase(const Key& k) {
+    iterator it = data_.find(k);
+    if (it == data_.end())
+      return 0;
+    erase(it);
+    return 1;
+  }
+
+  scoped_ptr<Value> take(iterator it) {
+    ASSERT(it != data_.end());
+    if (it == data_.end())
+      return scoped_ptr<Value>(NULL);
+
+    Key key = it->first;
+    scoped_ptr<Value> ret(it->second);
+    data_.erase(it);
+    data_.insert(std::pair<Key, Value*>(key, static_cast<Value*>(NULL)));
+    return ret.Pass();
+  }
+
+  scoped_ptr<Value> take(const Key& k) {
+    iterator it = find(k);
+    if (it == data_.end())
+      return scoped_ptr<Value>(NULL);
+
+    return take(it);
+  }
+
+  scoped_ptr<Value> take_and_erase(iterator it) {
+    ASSERT(it != data_.end());
+    if (it == data_.end())
+      return scoped_ptr<Value>(NULL);
+
+    scoped_ptr<Value> ret(it->second);
+    data_.erase(it);
+    return ret.Pass();
+  }
+
+  scoped_ptr<Value> take_and_erase(const Key& k) {
+    iterator it = find(k);
+    if (it == data_.end())
+      return scoped_ptr<Value>(NULL);
+
+    return take_and_erase(it);
+  }
+
+  // Returns the first element in the hash_map that matches the given key.
+  // If no such element exists it returns NULL.
+  Value* get(const Key& k) const {
+    const_iterator it = find(k);
+    if (it == end())
+      return 0;
+    return it->second;
+  }
+
+  inline bool contains(const Key& k) const { return data_.count(k); }
+
+  inline void clear() { STLDeleteValues(&data_); }
+
+  inline const_iterator find(const Key& k) const { return data_.find(k); }
+  inline iterator find(const Key& k) { return data_.find(k); }
+
+  inline size_t count(const Key& k) const { return data_.count(k); }
+  inline std::pair<const_iterator, const_iterator> equal_range(
+      const Key& k) const {
+    return data_.equal_range(k);
+  }
+  inline std::pair<iterator, iterator> equal_range(const Key& k) {
+    return data_.equal_range(k);
+  }
+
+  inline size_t size() const { return data_.size(); }
+  inline size_t max_size() const { return data_.max_size(); }
+
+  inline bool empty() const { return data_.empty(); }
+
+  inline size_t bucket_count() const { return data_.bucket_count(); }
+  inline void resize(size_t size) const { return data_.resize(size); }
+
+  inline iterator begin() { return data_.begin(); }
+  inline const_iterator begin() const { return data_.begin(); }
+  inline iterator end() { return data_.end(); }
+  inline const_iterator end() const { return data_.end(); }
+
+ private:
+  Container data_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedPtrHashMap);
+};
+
+}  // namespace cc
+
+#endif  // CC_SCOPED_PTR_HASH_MAP_H_
diff --git a/cc/scoped_ptr_vector.h b/cc/scoped_ptr_vector.h
new file mode 100644
index 0000000..05e38d9
--- /dev/null
+++ b/cc/scoped_ptr_vector.h
@@ -0,0 +1,100 @@
+// 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.
+
+#ifndef CC_SCOPED_PTR_VECTOR_H_
+#define CC_SCOPED_PTR_VECTOR_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+
+namespace cc {
+
+// This type acts like a vector<scoped_ptr> based on top of std::vector. The
+// ScopedPtrVector has ownership of all elements in the vector.
+template <typename T>
+class ScopedPtrVector {
+ public:
+  typedef typename std::vector<T*>::iterator iterator;
+  typedef typename std::vector<T*>::const_iterator const_iterator;
+  typedef typename std::vector<T*>::reverse_iterator reverse_iterator;
+  typedef typename std::vector<T*>::const_reverse_iterator
+      const_reverse_iterator;
+
+  ScopedPtrVector() {}
+
+  ~ScopedPtrVector() { clear(); }
+
+  size_t size() const {
+    return data_.size();
+  }
+
+  T* Peek(size_t index) const {
+    ASSERT(index < size());
+    return data_[index];
+  }
+
+  T* operator[](size_t index) const {
+    return Peek(index);
+  }
+
+  T* first() const {
+    ASSERT(!isEmpty());
+    return Peek(0);
+  }
+
+  T* last() const {
+    ASSERT(!isEmpty());
+    return Peek(size() - 1);
+  }
+
+  bool isEmpty() const {
+    return size() == 0;
+  }
+
+  scoped_ptr<T> take(size_t index) {
+    ASSERT(index < size());
+    scoped_ptr<T> ret(data_[index]);
+    data_[index] = NULL;
+    return ret.Pass();
+  }
+
+  void remove(size_t index) {
+    ASSERT(index < size());
+    delete data_[index];
+    data_.erase(data_.begin() + index);
+  }
+
+  void clear() {
+    STLDeleteElements(&data_);
+  }
+
+  void append(scoped_ptr<T> item) {
+    data_.push_back(item.release());
+  }
+
+  void insert(size_t index, scoped_ptr<T> item) {
+    ASSERT(index < size());
+    data_.insert(data_.begin() + index, item.release());
+  }
+
+  iterator begin() { return data_.begin(); }
+  const_iterator begin() const { return data_.begin(); }
+  iterator end() { return data_.end(); }
+  const_iterator end() const { return data_.end(); }
+
+  reverse_iterator rbegin() { return data_.rbegin(); }
+  const_reverse_iterator rbegin() const { return data_.rbegin(); }
+  reverse_iterator rend() { return data_.rend(); }
+  const_reverse_iterator rend() const { return data_.rend(); }
+
+ private:
+  std::vector<T*> data_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedPtrVector);
+};
+
+}  // namespace cc
+
+#endif  // CC_SCOPED_PTR_VECTOR_H_