[cc] Remove WTF constructs from CCLayerTreeHostClient

Pulling on this string ends up touching a lot of code, but it's all fairly
mechanical.  The only unfortunate part of this patch that it's not easy to pass
a scoped_ptr through CCThreadTask (so it just sends a raw pointer), but this
can get fixed after CCThreadTask switches to using base/.

BUG=154451

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

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

30 files changed, 135 insertions, 131 deletions

diff --git a/cc/CCDelegatedRendererLayerImplTest.cpp b/cc/CCDelegatedRendererLayerImplTest.cpp
index 2796974..41f740b 100644
--- a/cc/CCDelegatedRendererLayerImplTest.cpp
+++ b/cc/CCDelegatedRendererLayerImplTest.cpp
@@ -54,9 +54,9 @@ public:
     virtual void releaseContentsTexturesOnImplThread() OVERRIDE { }
 
 protected:
-    PassOwnPtr<CCGraphicsContext> createContext()
+    scoped_ptr<CCGraphicsContext> createContext()
     {
-        return FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3D));
+        return FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3D)).PassAs<CCGraphicsContext>();
     }
 
     DebugScopedSetImplThread m_alwaysImplThread;
diff --git a/cc/CCLayerTreeHost.cpp b/cc/CCLayerTreeHost.cpp
index a63bfe7..90b46c5 100644
--- a/cc/CCLayerTreeHost.cpp
+++ b/cc/CCLayerTreeHost.cpp
@@ -307,12 +307,12 @@ void CCLayerTreeHost::commitComplete()
     m_client->didCommit();
 }
 
-PassOwnPtr<CCGraphicsContext> CCLayerTreeHost::createContext()
+scoped_ptr<CCGraphicsContext> CCLayerTreeHost::createContext()
 {
     return m_client->createOutputSurface();
 }
 
-PassOwnPtr<CCInputHandler> CCLayerTreeHost::createInputHandler()
+scoped_ptr<CCInputHandler> CCLayerTreeHost::createInputHandler()
 {
     return m_client->createInputHandler();
 }
diff --git a/cc/CCLayerTreeHost.h b/cc/CCLayerTreeHost.h
index 48311f1..f16ff6b 100644
--- a/cc/CCLayerTreeHost.h
+++ b/cc/CCLayerTreeHost.h
@@ -101,8 +101,8 @@ public:
     void finishCommitOnImplThread(CCLayerTreeHostImpl*);
     void willCommit();
     void commitComplete();
-    PassOwnPtr<CCGraphicsContext> createContext();
-    PassOwnPtr<CCInputHandler> createInputHandler();
+    scoped_ptr<CCGraphicsContext> createContext();
+    scoped_ptr<CCInputHandler> createInputHandler();
     virtual PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHostImpl(CCLayerTreeHostImplClient*);
     void didLoseContext();
     enum RecreateResult {
diff --git a/cc/CCLayerTreeHostClient.h b/cc/CCLayerTreeHostClient.h
index 52c5bc0..1c88a75 100644
--- a/cc/CCLayerTreeHostClient.h
+++ b/cc/CCLayerTreeHostClient.h
@@ -5,7 +5,7 @@
 #ifndef CCLayerTreeHostClient_h
 #define CCLayerTreeHostClient_h
 
-#include <wtf/PassOwnPtr.h>
+#include "base/memory/scoped_ptr.h"
 
 namespace WebKit {
 class WebCompositorOutputSurface;
@@ -23,9 +23,9 @@ public:
     virtual void animate(double frameBeginTime) = 0;
     virtual void layout() = 0;
     virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0;
-    virtual PassOwnPtr<WebKit::WebCompositorOutputSurface> createOutputSurface() = 0;
+    virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface() = 0;
     virtual void didRecreateOutputSurface(bool success) = 0;
-    virtual PassOwnPtr<CCInputHandler> createInputHandler() = 0;
+    virtual scoped_ptr<CCInputHandler> createInputHandler() = 0;
     virtual void willCommit() = 0;
     virtual void didCommit() = 0;
     virtual void didCommitAndDrawFrame() = 0;
diff --git a/cc/CCLayerTreeHostImpl.cpp b/cc/CCLayerTreeHostImpl.cpp
index de8f668..e64a9f8 100644
--- a/cc/CCLayerTreeHostImpl.cpp
+++ b/cc/CCLayerTreeHostImpl.cpp
@@ -719,7 +719,7 @@ void CCLayerTreeHostImpl::setVisible(bool visible)
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
-bool CCLayerTreeHostImpl::initializeRenderer(PassOwnPtr<CCGraphicsContext> context)
+bool CCLayerTreeHostImpl::initializeRenderer(scoped_ptr<CCGraphicsContext> context)
 {
     // Since we will create a new resource provider, we cannot continue to use
     // the old resources (i.e. renderSurfaces and texture IDs). Clear them
@@ -731,7 +731,7 @@ bool CCLayerTreeHostImpl::initializeRenderer(PassOwnPtr<CCGraphicsContext> conte
     // Note: order is important here.
     m_renderer.clear();
     m_resourceProvider.clear();
-    m_context.clear();
+    m_context.reset();
 
     if (!context->bindToClient(this))
         return false;
@@ -748,7 +748,7 @@ bool CCLayerTreeHostImpl::initializeRenderer(PassOwnPtr<CCGraphicsContext> conte
         return false;
 
     m_resourceProvider = resourceProvider.release();
-    m_context = context;
+    m_context = context.Pass();
 
     if (!m_visible)
         m_renderer->setVisible(m_visible);
diff --git a/cc/CCLayerTreeHostImpl.h b/cc/CCLayerTreeHostImpl.h
index 691a9b0..9543fb6 100644
--- a/cc/CCLayerTreeHostImpl.h
+++ b/cc/CCLayerTreeHostImpl.h
@@ -114,7 +114,7 @@ public:
     void finishAllRendering();
     int sourceAnimationFrameNumber() const;
 
-    bool initializeRenderer(PassOwnPtr<CCGraphicsContext>);
+    bool initializeRenderer(scoped_ptr<CCGraphicsContext>);
     bool isContextLost();
     CCRenderer* renderer() { return m_renderer.get(); }
     const RendererCapabilities& rendererCapabilities() const;
@@ -250,7 +250,7 @@ private:
 
     void dumpRenderSurfaces(std::string*, int indent, const CCLayerImpl*) const;
 
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     OwnPtr<CCRenderer> m_renderer;
     OwnPtr<CCLayerImpl> m_rootLayerImpl;
diff --git a/cc/CCLayerTreeHostImplTest.cpp b/cc/CCLayerTreeHostImplTest.cpp
index 4033058..4b027d4 100644
--- a/cc/CCLayerTreeHostImplTest.cpp
+++ b/cc/CCLayerTreeHostImplTest.cpp
@@ -74,7 +74,7 @@ public:
     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) OVERRIDE { }
     virtual void releaseContentsTexturesOnImplThread() OVERRIDE { }
 
-    PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, PassOwnPtr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)
+    PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHost(bool partialSwap, scoped_ptr<CCGraphicsContext> graphicsContext, PassOwnPtr<CCLayerImpl> rootPtr)
     {
         CCSettings::setPartialSwapEnabled(partialSwap);
 
@@ -83,7 +83,7 @@ public:
 
         OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, this);
 
-        myHostImpl->initializeRenderer(graphicsContext);
+        myHostImpl->initializeRenderer(graphicsContext.Pass());
         myHostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
 
         OwnPtr<CCLayerImpl> root = rootPtr;
@@ -162,9 +162,9 @@ public:
     }
 
 protected:
-    PassOwnPtr<CCGraphicsContext> createContext()
+    scoped_ptr<CCGraphicsContext> createContext()
     {
-        return FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3D));
+        return FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3D)).PassAs<CCGraphicsContext>();
     }
 
     DebugScopedSetImplThread m_alwaysImplThread;
@@ -321,7 +321,7 @@ TEST_F(CCLayerTreeHostImplTest, scrollWithoutRenderer)
     m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // Initialization will fail here.
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)));
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<CCGraphicsContext>());
     m_hostImpl->setViewportSize(IntSize(10, 10), IntSize(10, 10));
 
     setupScrollAndContentsLayers(IntSize(100, 100));
@@ -1757,9 +1757,9 @@ public:
 // viewport size is never set.
 TEST_F(CCLayerTreeHostImplTest, reshapeNotCalledUntilDraw)
 {
-    OwnPtr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new ReshapeTrackerContext));
+    scoped_ptr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new ReshapeTrackerContext)).PassAs<CCGraphicsContext>();
     ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(ccContext->context3D());
-    m_hostImpl->initializeRenderer(ccContext.release());
+    m_hostImpl->initializeRenderer(ccContext.Pass());
 
     CCLayerImpl* root = new FakeDrawableCCLayerImpl(1);
     root->setAnchorPoint(FloatPoint(0, 0));
@@ -1800,7 +1800,7 @@ private:
 // where it should request to swap only the subBuffer that is damaged.
 TEST_F(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect)
 {
-    OwnPtr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapTrackerContext));
+    scoped_ptr<CCGraphicsContext> ccContext = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapTrackerContext)).PassAs<CCGraphicsContext>();
     PartialSwapTrackerContext* partialSwapTracker = static_cast<PartialSwapTrackerContext*>(ccContext->context3D());
 
     // This test creates its own CCLayerTreeHostImpl, so
@@ -1808,7 +1808,7 @@ TEST_F(CCLayerTreeHostImplTest, partialSwapReceivesDamageRect)
     CCLayerTreeSettings settings;
     CCSettings::setPartialSwapEnabled(true);
     OwnPtr<CCLayerTreeHostImpl> layerTreeHostImpl = CCLayerTreeHostImpl::create(settings, this);
-    layerTreeHostImpl->initializeRenderer(ccContext.release());
+    layerTreeHostImpl->initializeRenderer(ccContext.Pass());
     layerTreeHostImpl->setViewportSize(IntSize(500, 500), IntSize(500, 500));
 
     CCLayerImpl* root = new FakeDrawableCCLayerImpl(1);
@@ -2014,7 +2014,7 @@ public:
 
 TEST_F(CCLayerTreeHostImplTest, noPartialSwap)
 {
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext)).PassAs<CCGraphicsContext>();
     MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
@@ -2022,7 +2022,7 @@ TEST_F(CCLayerTreeHostImplTest, noPartialSwap)
     harness.mustSetScissor(0, 0, 10, 10);
 
     // Run test case
-    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.release(), FakeLayerWithQuads::create(1));
+    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.Pass(), FakeLayerWithQuads::create(1));
 
     CCLayerTreeHostImpl::FrameData frame;
     EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
@@ -2033,11 +2033,11 @@ TEST_F(CCLayerTreeHostImplTest, noPartialSwap)
 
 TEST_F(CCLayerTreeHostImplTest, partialSwap)
 {
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockContext)).PassAs<CCGraphicsContext>();
     MockContext* mockContext = static_cast<MockContext*>(context->context3D());
     MockContextHarness harness(mockContext);
 
-    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, context.release(), FakeLayerWithQuads::create(1));
+    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(true, context.Pass(), FakeLayerWithQuads::create(1));
 
     // The first frame is not a partially-swapped one.
     harness.mustSetScissor(0, 0, 10, 10);
@@ -2091,11 +2091,11 @@ static PassOwnPtr<CCLayerTreeHostImpl> setupLayersForOpacity(bool partialSwap, C
 {
     CCSettings::setPartialSwapEnabled(partialSwap);
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     CCLayerTreeSettings settings;
     OwnPtr<CCLayerTreeHostImpl> myHostImpl = CCLayerTreeHostImpl::create(settings, client);
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(100, 100), IntSize(100, 100));
 
     /*
@@ -2247,7 +2247,7 @@ TEST_F(CCLayerTreeHostImplTest, finishAllRenderingAfterContextLost)
     m_hostImpl = CCLayerTreeHostImpl::create(settings, this);
 
     // The context initialization will fail, but we should still be able to call finishAllRendering() without any ill effects.
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)));
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFails)).PassAs<CCGraphicsContext>());
     m_hostImpl->finishAllRendering();
 }
 
@@ -2285,14 +2285,14 @@ TEST_F(CCLayerTreeHostImplTest, contextLostDuringInitialize)
     for (unsigned i = 0; i < kMakeCurrentSuccessesNeededForSuccessfulInitialization; ++i) {
         // The context will get lost during initialization, we shouldn't crash. We
         // should also be in a consistent state.
-        EXPECT_FALSE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(i)))));
+        EXPECT_FALSE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(i))).PassAs<CCGraphicsContext>()));
         EXPECT_EQ(0, m_hostImpl->context());
         EXPECT_EQ(0, m_hostImpl->renderer());
         EXPECT_EQ(0, m_hostImpl->resourceProvider());
         EXPECT_TRUE(m_hostImpl->initializeRenderer(createContext()));
     }
 
-    EXPECT_TRUE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(kMakeCurrentSuccessesNeededForSuccessfulInitialization)))));
+    EXPECT_TRUE(m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DMakeCurrentFailsEventually(kMakeCurrentSuccessesNeededForSuccessfulInitialization))).PassAs<CCGraphicsContext>()));
     EXPECT_TRUE(m_hostImpl->context());
     EXPECT_TRUE(m_hostImpl->renderer());
     EXPECT_TRUE(m_hostImpl->resourceProvider());
@@ -2620,7 +2620,7 @@ TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
     rootLayer->addChild(delegatedRendererLayer.release());
 
     // Use a context that supports IOSurfaces
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DWithIOSurface)));
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new FakeWebGraphicsContext3DWithIOSurface)).PassAs<CCGraphicsContext>());
 
     hwVideoFrame.setTextureId(m_hostImpl->resourceProvider()->graphicsContext3D()->createTexture());
 
@@ -2636,7 +2636,7 @@ TEST_F(CCLayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
 
     // Lose the context, replacing it with a StrictWebGraphicsContext3DWithIOSurface,
     // that will warn if any resource from the previous context gets used.
-    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new StrictWebGraphicsContext3DWithIOSurface)));
+    m_hostImpl->initializeRenderer(FakeWebCompositorOutputSurface::create(adoptPtr(new StrictWebGraphicsContext3DWithIOSurface)).PassAs<CCGraphicsContext>());
 
     // Create dummy resources so that looking up an old resource will get an
     // invalid texture id mapping.
@@ -2747,9 +2747,9 @@ TEST_F(CCLayerTreeHostImplTest, layersFreeTextures)
     rootLayer->addChild(ioSurfaceLayer.release());
 
     // Lose the context, replacing it with a TrackingWebGraphicsContext3D (which the CCLayerTreeHostImpl takes ownership of).
-    OwnPtr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new TrackingWebGraphicsContext3D)));
+    scoped_ptr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new TrackingWebGraphicsContext3D)));
     TrackingWebGraphicsContext3D* trackingWebGraphicsContext = static_cast<TrackingWebGraphicsContext3D*>(ccContext->context3D());
-    m_hostImpl->initializeRenderer(ccContext.release());
+    m_hostImpl->initializeRenderer(ccContext.Pass());
 
     m_hostImpl->setRootLayer(rootLayer.release());
 
@@ -2775,11 +2775,11 @@ public:
 
 TEST_F(CCLayerTreeHostImplTest, hasTransparentBackground)
 {
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockDrawQuadsToFillScreenContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new MockDrawQuadsToFillScreenContext)).PassAs<CCGraphicsContext>();
     MockDrawQuadsToFillScreenContext* mockContext = static_cast<MockDrawQuadsToFillScreenContext*>(context->context3D());
 
     // Run test case
-    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.release(), CCLayerImpl::create(1));
+    OwnPtr<CCLayerTreeHostImpl> myHostImpl = createLayerTreeHost(false, context.Pass(), CCLayerImpl::create(1));
     myHostImpl->setBackgroundColor(SK_ColorWHITE);
 
     // Verify one quad is drawn when transparent background set is not set.
@@ -2819,9 +2819,9 @@ static void addDrawingLayerTo(CCLayerImpl* parent, int id, const IntRect& layerR
 
 static void setupLayersForTextureCaching(CCLayerTreeHostImpl* layerTreeHostImpl, CCLayerImpl*& rootPtr, CCLayerImpl*& intermediateLayerPtr, CCLayerImpl*& surfaceLayerPtr, CCLayerImpl*& childPtr, const IntSize& rootSize)
 {
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
-    layerTreeHostImpl->initializeRenderer(context.release());
+    layerTreeHostImpl->initializeRenderer(context.Pass());
     layerTreeHostImpl->setViewportSize(rootSize, rootSize);
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -2863,11 +2863,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithClipping)
     CCLayerImpl* rootPtr;
     CCLayerImpl* surfaceLayerPtr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(100, 100);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -2975,11 +2975,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusion)
     CCLayerImpl* layerS1Ptr;
     CCLayerImpl* layerS2Ptr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -3088,11 +3088,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionEarlyOut)
     CCLayerImpl* layerS1Ptr;
     CCLayerImpl* layerS2Ptr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -3202,11 +3202,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalOverInternal)
     CCLayerImpl* layerS1Ptr;
     CCLayerImpl* layerS2Ptr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -3285,11 +3285,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionExternalNotAligned)
     CCLayerImpl* rootPtr;
     CCLayerImpl* layerS1Ptr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -3370,11 +3370,11 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithOcclusionPartialSwap)
     CCLayerImpl* layerS1Ptr;
     CCLayerImpl* layerS2Ptr;
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
 
     IntSize rootSize(1000, 1000);
 
-    myHostImpl->initializeRenderer(context.release());
+    myHostImpl->initializeRenderer(context.Pass());
     myHostImpl->setViewportSize(IntSize(rootSize.width(), rootSize.height()), IntSize(rootSize.width(), rootSize.height()));
 
     OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
@@ -3491,8 +3491,8 @@ TEST_F(CCLayerTreeHostImplTest, textureCachingWithScissor)
     IntRect childRect(10, 10, 50, 50);
     IntRect grandChildRect(5, 5, 150, 150);
 
-    OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
-    myHostImpl->initializeRenderer(context.release());
+    scoped_ptr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext)).PassAs<CCGraphicsContext>();
+    myHostImpl->initializeRenderer(context.Pass());
 
     root->setAnchorPoint(FloatPoint(0, 0));
     root->setPosition(FloatPoint(rootRect.x(), rootRect.y()));
@@ -4205,7 +4205,7 @@ static void verifyRenderPassTestData(TestCase& testCase, RenderPassRemovalTestDa
 
 TEST_F(CCLayerTreeHostImplTest, testRemoveRenderPasses)
 {
-    OwnPtr<CCGraphicsContext> context(createContext());
+    scoped_ptr<CCGraphicsContext> context(createContext());
     ASSERT_TRUE(context->context3D());
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
 
diff --git a/cc/CCLayerTreeHostTest.cpp b/cc/CCLayerTreeHostTest.cpp
index 792d0a5..ff85e35 100644
--- a/cc/CCLayerTreeHostTest.cpp
+++ b/cc/CCLayerTreeHostTest.cpp
@@ -2781,9 +2781,9 @@ public:
             m_children.append(ContentLayerChromiumWithUpdateTracking::create(&m_client));
     }
 
-    virtual PassOwnPtr<WebKit::WebCompositorOutputSurface> createOutputSurface()
+    virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface()
     {
-        return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext::create(WebGraphicsContext3D::Attributes()));
+        return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext::create(WebGraphicsContext3D::Attributes())).PassAs<WebKit::WebCompositorOutputSurface>();
     }
 
     virtual void beginTest()
diff --git a/cc/CCPrioritizedTextureTest.cpp b/cc/CCPrioritizedTextureTest.cpp
index f5b5de2..04d5ab3 100644
--- a/cc/CCPrioritizedTextureTest.cpp
+++ b/cc/CCPrioritizedTextureTest.cpp
@@ -95,7 +95,7 @@ protected:
     const IntSize m_textureSize;
     const GC3Denum m_textureFormat;
     WebCompositorInitializer m_compositorInitializer;
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
 };
 
diff --git a/cc/CCRendererGLTest.cpp b/cc/CCRendererGLTest.cpp
index ba72399..7c84853 100644
--- a/cc/CCRendererGLTest.cpp
+++ b/cc/CCRendererGLTest.cpp
@@ -134,7 +134,7 @@ protected:
     WebGraphicsMemoryAllocation m_suggestHaveBackbufferNo;
 
     WebCompositorInitializer m_compositorInitializer;
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     FakeCCRendererClient m_mockClient;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     FakeCCRendererGL m_renderer;
@@ -297,7 +297,7 @@ TEST(CCRendererGLTest2, initializationDoesNotMakeSynchronousCalls)
 {
     CCScopedSettings scopedSettings;
     FakeCCRendererClient mockClient;
-    OwnPtr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new ForbidSynchronousCallContext)));
+    scoped_ptr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new ForbidSynchronousCallContext)));
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
     FakeCCRendererGL renderer(&mockClient, resourceProvider.get());
 
@@ -341,7 +341,7 @@ TEST(CCRendererGLTest2, initializationWithQuicklyLostContextDoesNotAssert)
 {
     CCScopedSettings scopedSettings;
     FakeCCRendererClient mockClient;
-    OwnPtr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new LoseContextOnFirstGetContext)));
+    scoped_ptr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new LoseContextOnFirstGetContext)));
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
     FakeCCRendererGL renderer(&mockClient, resourceProvider.get());
 
@@ -363,7 +363,7 @@ public:
 TEST(CCRendererGLTest2, initializationWithoutGpuMemoryManagerExtensionSupportShouldDefaultToNonZeroAllocation)
 {
     FakeCCRendererClient mockClient;
-    OwnPtr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new ContextThatDoesNotSupportMemoryManagmentExtensions)));
+    scoped_ptr<CCGraphicsContext> context(FakeWebCompositorOutputSurface::create(adoptPtr(new ContextThatDoesNotSupportMemoryManagmentExtensions)));
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
     FakeCCRendererGL renderer(&mockClient, resourceProvider.get());
 
@@ -390,7 +390,7 @@ private:
 TEST(CCRendererGLTest2, opaqueBackground)
 {
     FakeCCRendererClient mockClient;
-    OwnPtr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new ClearCountingContext)));
+    scoped_ptr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(ccContext->context3D());
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(ccContext.get()));
     FakeCCRendererGL renderer(&mockClient, resourceProvider.get());
@@ -413,7 +413,7 @@ TEST(CCRendererGLTest2, opaqueBackground)
 TEST(CCRendererGLTest2, transparentBackground)
 {
     FakeCCRendererClient mockClient;
-    OwnPtr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new ClearCountingContext)));
+    scoped_ptr<CCGraphicsContext> ccContext(FakeWebCompositorOutputSurface::create(adoptPtr(new ClearCountingContext)));
     ClearCountingContext* context = static_cast<ClearCountingContext*>(ccContext->context3D());
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(ccContext.get()));
     FakeCCRendererGL renderer(&mockClient, resourceProvider.get());
diff --git a/cc/CCRendererSoftwareTest.cpp b/cc/CCRendererSoftwareTest.cpp
index fb057c8..95440e6 100644
--- a/cc/CCRendererSoftwareTest.cpp
+++ b/cc/CCRendererSoftwareTest.cpp
@@ -55,7 +55,7 @@ public:
 protected:
     DebugScopedSetImplThread m_alwaysImplThread;
 
-    OwnPtr<FakeWebCompositorOutputSurface> m_outputSurface;
+    scoped_ptr<FakeWebCompositorOutputSurface> m_outputSurface;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     OwnPtr<CCRendererSoftware> m_renderer;
     IntSize m_viewportSize;
diff --git a/cc/CCResourceProviderTest.cpp b/cc/CCResourceProviderTest.cpp
index 3e090cf..637c3a4 100644
--- a/cc/CCResourceProviderTest.cpp
+++ b/cc/CCResourceProviderTest.cpp
@@ -301,7 +301,7 @@ public:
 protected:
     DebugScopedSetImplThread implThread;
     OwnPtr<ContextSharedData> m_sharedData;
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
 };
 
@@ -416,7 +416,7 @@ TEST_P(CCResourceProviderTest, TransferResources)
     if (GetParam() != CCResourceProvider::GLTexture)
         return;
 
-    OwnPtr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get())));
+    scoped_ptr<CCGraphicsContext> childContext(FakeWebCompositorOutputSurface::create(ResourceProviderContext::create(m_sharedData.get())));
     OwnPtr<CCResourceProvider> childResourceProvider(CCResourceProvider::create(childContext.get()));
 
     IntSize size(1, 1);
diff --git a/cc/CCScopedTextureTest.cpp b/cc/CCScopedTextureTest.cpp
index 6874527..b707a7f 100644
--- a/cc/CCScopedTextureTest.cpp
+++ b/cc/CCScopedTextureTest.cpp
@@ -21,7 +21,7 @@ namespace {
 
 TEST(CCScopedTextureTest, NewScopedTexture)
 {
-    OwnPtr<CCGraphicsContext> context(createFakeCCGraphicsContext());
+    scoped_ptr<CCGraphicsContext> context(createFakeCCGraphicsContext());
     DebugScopedSetImplThread implThread;
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
     OwnPtr<CCScopedTexture> texture = CCScopedTexture::create(resourceProvider.get());
@@ -36,7 +36,7 @@ TEST(CCScopedTextureTest, NewScopedTexture)
 
 TEST(CCScopedTextureTest, CreateScopedTexture)
 {
-    OwnPtr<CCGraphicsContext> context(createFakeCCGraphicsContext());
+    scoped_ptr<CCGraphicsContext> context(createFakeCCGraphicsContext());
     DebugScopedSetImplThread implThread;
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
     OwnPtr<CCScopedTexture> texture = CCScopedTexture::create(resourceProvider.get());
@@ -53,7 +53,7 @@ TEST(CCScopedTextureTest, CreateScopedTexture)
 
 TEST(CCScopedTextureTest, ScopedTextureIsDeleted)
 {
-    OwnPtr<CCGraphicsContext> context(createFakeCCGraphicsContext());
+    scoped_ptr<CCGraphicsContext> context(createFakeCCGraphicsContext());
     DebugScopedSetImplThread implThread;
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
 
@@ -81,7 +81,7 @@ TEST(CCScopedTextureTest, ScopedTextureIsDeleted)
 
 TEST(CCScopedTextureTest, LeakScopedTexture)
 {
-    OwnPtr<CCGraphicsContext> context(createFakeCCGraphicsContext());
+    scoped_ptr<CCGraphicsContext> context(createFakeCCGraphicsContext());
     DebugScopedSetImplThread implThread;
     OwnPtr<CCResourceProvider> resourceProvider(CCResourceProvider::create(context.get()));
 
diff --git a/cc/CCSingleThreadProxy.cpp b/cc/CCSingleThreadProxy.cpp
index cc7d538..0d63659 100644
--- a/cc/CCSingleThreadProxy.cpp
+++ b/cc/CCSingleThreadProxy.cpp
@@ -89,10 +89,10 @@ bool CCSingleThreadProxy::isStarted() const
 bool CCSingleThreadProxy::initializeContext()
 {
     ASSERT(CCProxy::isMainThread());
-    OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
-    if (!context)
+    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    if (!context.get())
         return false;
-    m_contextBeforeInitialization = context.release();
+    m_contextBeforeInitialization = context.Pass();
     return true;
 }
 
@@ -110,10 +110,10 @@ void CCSingleThreadProxy::setVisible(bool visible)
 bool CCSingleThreadProxy::initializeRenderer()
 {
     ASSERT(CCProxy::isMainThread());
-    ASSERT(m_contextBeforeInitialization);
+    ASSERT(m_contextBeforeInitialization.get());
     {
         DebugScopedSetImplThread impl;
-        bool ok = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitialization.release());
+        bool ok = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitialization.Pass());
         if (ok) {
             m_rendererInitialized = true;
             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
@@ -129,8 +129,8 @@ bool CCSingleThreadProxy::recreateContext()
     ASSERT(CCProxy::isMainThread());
     ASSERT(m_contextLost);
 
-    OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
-    if (!context)
+    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    if (!context.get())
         return false;
 
     bool initialized;
@@ -139,7 +139,7 @@ bool CCSingleThreadProxy::recreateContext()
         DebugScopedSetImplThread impl;
         if (!m_layerTreeHostImpl->contentsTexturesPurged())
             m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
-        initialized = m_layerTreeHostImpl->initializeRenderer(context.release());
+        initialized = m_layerTreeHostImpl->initializeRenderer(context.Pass());
         if (initialized) {
             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
         }
diff --git a/cc/CCSingleThreadProxy.h b/cc/CCSingleThreadProxy.h
index 4a9278e..12ecb26 100644
--- a/cc/CCSingleThreadProxy.h
+++ b/cc/CCSingleThreadProxy.h
@@ -72,7 +72,7 @@ private:
 
     // Holds on to the context between initializeContext() and initializeRenderer() calls. Shouldn't
     // be used for anything else.
-    OwnPtr<CCGraphicsContext> m_contextBeforeInitialization;
+    scoped_ptr<CCGraphicsContext> m_contextBeforeInitialization;
 
     // Used on the CCThread, but checked on main thread during initialization/shutdown.
     OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
diff --git a/cc/CCTextureUpdateControllerTest.cpp b/cc/CCTextureUpdateControllerTest.cpp
index b57fad2..610e6d3 100644
--- a/cc/CCTextureUpdateControllerTest.cpp
+++ b/cc/CCTextureUpdateControllerTest.cpp
@@ -179,7 +179,7 @@ protected:
 
 protected:
     // Classes required to interact and test the CCTextureUpdateController
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     OwnPtr<CCTextureUpdateQueue> m_queue;
     TextureForUploadTest m_textures[4];
diff --git a/cc/CCThreadProxy.cpp b/cc/CCThreadProxy.cpp
index 84a7edcb..81a92f8 100644
--- a/cc/CCThreadProxy.cpp
+++ b/cc/CCThreadProxy.cpp
@@ -150,12 +150,12 @@ bool CCThreadProxy::isStarted() const
 bool CCThreadProxy::initializeContext()
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeContext");
-    OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
-    if (!context)
+    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    if (!context.get())
         return false;
 
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeContextOnImplThread,
-                                                       context.leakPtr()));
+                                                       context.release()));
     return true;
 }
 
@@ -216,8 +216,8 @@ bool CCThreadProxy::recreateContext()
     ASSERT(isMainThread());
 
     // Try to create the context.
-    OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
-    if (!context)
+    scoped_ptr<CCGraphicsContext> context = m_layerTreeHost->createContext();
+    if (!context.get())
         return false;
     if (m_layerTreeHost->needsSharedContext())
         if (!WebSharedGraphicsContext3D::createCompositorThreadContext())
@@ -232,7 +232,7 @@ bool CCThreadProxy::recreateContext()
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::recreateContextOnImplThread,
                                                        &completion,
-                                                       context.leakPtr(),
+                                                       context.release(),
                                                        &recreateSucceeded,
                                                        &capabilities));
     completion.wait();
@@ -394,7 +394,7 @@ void CCThreadProxy::start()
     // Create LayerTreeHostImpl.
     DebugScopedSetMainThreadBlocked mainThreadBlocked;
     CCCompletionEvent completion;
-    OwnPtr<CCInputHandler> handler = m_layerTreeHost->createInputHandler();
+    scoped_ptr<CCInputHandler> handler = m_layerTreeHost->createInputHandler();
     CCProxy::implThread()->postTask(createCCThreadTask(this, &CCThreadProxy::initializeImplOnImplThread, &completion, handler.release()));
     completion.wait();
 
@@ -696,7 +696,7 @@ CCScheduledActionDrawAndSwapResult CCThreadProxy::scheduledActionDrawAndSwapInte
     double monotonicTime = monotonicallyIncreasingTime();
     double wallClockTime = currentTime();
 
-    if (m_inputHandlerOnImplThread)
+    if (m_inputHandlerOnImplThread.get())
         m_inputHandlerOnImplThread->animate(monotonicTime);
     m_layerTreeHostImpl->animate(monotonicTime, wallClockTime);
 
@@ -866,7 +866,7 @@ void CCThreadProxy::tryToRecreateContext()
         m_contextRecreationTimer.clear();
 }
 
-void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, PassOwnPtr<CCInputHandler> popHandler)
+void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, CCInputHandler* handler)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeImplOnImplThread");
     ASSERT(isImplThread());
@@ -880,8 +880,8 @@ void CCThreadProxy::initializeImplOnImplThread(CCCompletionEvent* completion, Pa
     m_schedulerOnImplThread = CCScheduler::create(this, frameRateController.release());
     m_schedulerOnImplThread->setVisible(m_layerTreeHostImpl->visible());
 
-    m_inputHandlerOnImplThread = popHandler;
-    if (m_inputHandlerOnImplThread)
+    m_inputHandlerOnImplThread = scoped_ptr<CCInputHandler>(handler);
+    if (m_inputHandlerOnImplThread.get())
         m_inputHandlerOnImplThread->bindToClient(m_layerTreeHostImpl.get());
 
     completion->signal();
@@ -891,15 +891,15 @@ void CCThreadProxy::initializeContextOnImplThread(CCGraphicsContext* context)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeContextOnImplThread");
     ASSERT(isImplThread());
-    m_contextBeforeInitializationOnImplThread = adoptPtr(context);
+    m_contextBeforeInitializationOnImplThread = scoped_ptr<CCGraphicsContext>(context).Pass();
 }
 
 void CCThreadProxy::initializeRendererOnImplThread(CCCompletionEvent* completion, bool* initializeSucceeded, RendererCapabilities* capabilities)
 {
     TRACE_EVENT0("cc", "CCThreadProxy::initializeRendererOnImplThread");
     ASSERT(isImplThread());
-    ASSERT(m_contextBeforeInitializationOnImplThread);
-    *initializeSucceeded = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitializationOnImplThread.release());
+    ASSERT(m_contextBeforeInitializationOnImplThread.get());
+    *initializeSucceeded = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitializationOnImplThread.Pass());
     if (*initializeSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->setSwapBuffersCompleteSupported(
@@ -916,7 +916,7 @@ void CCThreadProxy::layerTreeHostClosedOnImplThread(CCCompletionEvent* completio
     CCResourceProvider::debugNotifyEnterZone(0x6000000);
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     CCResourceProvider::debugNotifyLeaveZone();
-    m_inputHandlerOnImplThread.clear();
+    m_inputHandlerOnImplThread.reset();
     m_layerTreeHostImpl.clear();
     m_schedulerOnImplThread.clear();
     completion->signal();
@@ -940,7 +940,7 @@ void CCThreadProxy::recreateContextOnImplThread(CCCompletionEvent* completion, C
     CCResourceProvider::debugNotifyEnterZone(0x7000000);
     m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
     CCResourceProvider::debugNotifyLeaveZone();
-    *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(adoptPtr(contextPtr));
+    *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(scoped_ptr<CCGraphicsContext>(contextPtr).Pass());
     if (*recreateSucceeded) {
         *capabilities = m_layerTreeHostImpl->rendererCapabilities();
         m_schedulerOnImplThread->didRecreateContext();
diff --git a/cc/CCThreadProxy.h b/cc/CCThreadProxy.h
index c7b1094..9a44225 100644
--- a/cc/CCThreadProxy.h
+++ b/cc/CCThreadProxy.h
@@ -113,7 +113,7 @@ private:
     void requestReadbackOnImplThread(ReadbackRequest*);
     void requestStartPageScaleAnimationOnImplThread(IntSize targetPosition, bool useAnchor, float scale, double durationSec);
     void finishAllRenderingOnImplThread(CCCompletionEvent*);
-    void initializeImplOnImplThread(CCCompletionEvent*, PassOwnPtr<CCInputHandler>);
+    void initializeImplOnImplThread(CCCompletionEvent*, CCInputHandler*);
     void setSurfaceReadyOnImplThread();
     void setVisibleOnImplThread(CCCompletionEvent*, bool);
     void initializeContextOnImplThread(CCGraphicsContext*);
@@ -142,7 +142,7 @@ private:
 
     OwnPtr<CCLayerTreeHostImpl> m_layerTreeHostImpl;
 
-    OwnPtr<CCInputHandler> m_inputHandlerOnImplThread;
+    scoped_ptr<CCInputHandler> m_inputHandlerOnImplThread;
 
     OwnPtr<CCScheduler> m_schedulerOnImplThread;
 
@@ -150,7 +150,7 @@ private:
 
     // Holds on to the context we might use for compositing in between initializeContext()
     // and initializeRenderer() calls.
-    OwnPtr<CCGraphicsContext> m_contextBeforeInitializationOnImplThread;
+    scoped_ptr<CCGraphicsContext> m_contextBeforeInitializationOnImplThread;
 
     // Set when the main thread is waiting on a scheduledActionBeginFrame to be issued.
     CCCompletionEvent* m_beginFrameCompletionEventOnImplThread;
diff --git a/cc/CCThreadedTest.cpp b/cc/CCThreadedTest.cpp
index 7362747..cceb2e8 100644
--- a/cc/CCThreadedTest.cpp
+++ b/cc/CCThreadedTest.cpp
@@ -86,9 +86,9 @@ bool TestHooks::prepareToDrawOnCCThread(cc::CCLayerTreeHostImpl*)
     return true;
 }
 
-PassOwnPtr<WebCompositorOutputSurface> TestHooks::createOutputSurface()
+scoped_ptr<WebCompositorOutputSurface> TestHooks::createOutputSurface()
 {
-    return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebGraphicsContext3D::Attributes()));
+    return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3DWithTextureTracking::create(WebGraphicsContext3D::Attributes())).PassAs<WebCompositorOutputSurface>();
 }
 
 PassOwnPtr<MockLayerTreeHostImpl> MockLayerTreeHostImpl::create(TestHooks* testHooks, const CCLayerTreeSettings& settings, CCLayerTreeHostImplClient* client)
@@ -210,7 +210,7 @@ public:
         m_testHooks->applyScrollAndScale(scrollDelta, scale);
     }
 
-    virtual PassOwnPtr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE
+    virtual scoped_ptr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE
     {
         return m_testHooks->createOutputSurface();
     }
@@ -220,9 +220,9 @@ public:
         m_testHooks->didRecreateOutputSurface(succeeded);
     }
 
-    virtual PassOwnPtr<CCInputHandler> createInputHandler() OVERRIDE
+    virtual scoped_ptr<CCInputHandler> createInputHandler() OVERRIDE
     {
-        return nullptr;
+        return scoped_ptr<CCInputHandler>();
     }
 
     virtual void willCommit() OVERRIDE
diff --git a/cc/CCThreadedTest.h b/cc/CCThreadedTest.h
index 61a08b5..fcbc5c2 100644
--- a/cc/CCThreadedTest.h
+++ b/cc/CCThreadedTest.h
@@ -45,7 +45,7 @@ public:
     virtual void notifyAnimationStarted(double time) OVERRIDE { }
     virtual void notifyAnimationFinished(double time) OVERRIDE { }
 
-    virtual PassOwnPtr<WebKit::WebCompositorOutputSurface> createOutputSurface();
+    virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface();
 };
 
 class TimeoutTask;
diff --git a/cc/TiledLayerChromiumTest.cpp b/cc/TiledLayerChromiumTest.cpp
index 74a3d58..7c08690 100644
--- a/cc/TiledLayerChromiumTest.cpp
+++ b/cc/TiledLayerChromiumTest.cpp
@@ -159,7 +159,7 @@ public:
 
 public:
     WebKitTests::WebCompositorInitializer m_compositorInitializer;
-    OwnPtr<CCGraphicsContext> m_context;
+    scoped_ptr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
     OwnPtr<CCTextureUpdateQueue> m_queue;
     CCRenderingStats m_stats;
diff --git a/cc/test/FakeCCGraphicsContext.h b/cc/test/FakeCCGraphicsContext.h
index 2b35836..a592bf0 100644
--- a/cc/test/FakeCCGraphicsContext.h
+++ b/cc/test/FakeCCGraphicsContext.h
@@ -12,9 +12,9 @@
 
 namespace WebKit {
 
-static inline PassOwnPtr<cc::CCGraphicsContext> createFakeCCGraphicsContext()
+static inline scoped_ptr<cc::CCGraphicsContext> createFakeCCGraphicsContext()
 {
-    return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes()));
+    return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes())).PassAs<cc::CCGraphicsContext>();
 }
 
 } // namespace WebKit
diff --git a/cc/test/FakeCCLayerTreeHostClient.cpp b/cc/test/FakeCCLayerTreeHostClient.cpp
index 0c081a5..b658810 100644
--- a/cc/test/FakeCCLayerTreeHostClient.cpp
+++ b/cc/test/FakeCCLayerTreeHostClient.cpp
@@ -8,15 +8,15 @@
 
 namespace cc {
 
-PassOwnPtr<WebKit::WebCompositorOutputSurface> FakeCCLayerTreeHostClient::createOutputSurface()
+scoped_ptr<WebKit::WebCompositorOutputSurface> FakeCCLayerTreeHostClient::createOutputSurface()
 {
     WebKit::WebGraphicsContext3D::Attributes attrs;
-    return WebKit::FakeWebCompositorOutputSurface::create(WebKit::CompositorFakeWebGraphicsContext3D::create(attrs));
+    return scoped_ptr<WebKit::WebCompositorOutputSurface>(WebKit::FakeWebCompositorOutputSurface::create(WebKit::CompositorFakeWebGraphicsContext3D::create(attrs)));
 }
 
-PassOwnPtr<CCInputHandler> FakeCCLayerTreeHostClient::createInputHandler()
+scoped_ptr<CCInputHandler> FakeCCLayerTreeHostClient::createInputHandler()
 {
-    return nullptr;
+    return scoped_ptr<CCInputHandler>();
 }
 
 }
diff --git a/cc/test/FakeCCLayerTreeHostClient.h b/cc/test/FakeCCLayerTreeHostClient.h
index 2813113..ef71715 100644
--- a/cc/test/FakeCCLayerTreeHostClient.h
+++ b/cc/test/FakeCCLayerTreeHostClient.h
@@ -6,6 +6,7 @@
 
 #include "config.h"
 
+#include "base/memory/scoped_ptr.h"
 #include "CCInputHandler.h"
 #include "CCLayerTreeHost.h"
 #include "CompositorFakeWebGraphicsContext3D.h"
@@ -21,9 +22,9 @@ public:
     virtual void layout() OVERRIDE { }
     virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) OVERRIDE { }
 
-    virtual PassOwnPtr<WebKit::WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
+    virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
     virtual void didRecreateOutputSurface(bool success) OVERRIDE { }
-    virtual PassOwnPtr<CCInputHandler> createInputHandler() OVERRIDE;
+    virtual scoped_ptr<CCInputHandler> createInputHandler() OVERRIDE;
     virtual void willCommit() OVERRIDE { }
     virtual void didCommit() OVERRIDE { }
     virtual void didCommitAndDrawFrame() OVERRIDE { }
diff --git a/cc/test/FakeWebCompositorOutputSurface.h b/cc/test/FakeWebCompositorOutputSurface.h
index 01b6638..c056faf 100644
--- a/cc/test/FakeWebCompositorOutputSurface.h
+++ b/cc/test/FakeWebCompositorOutputSurface.h
@@ -5,6 +5,7 @@
 #ifndef FakeWebCompositorOutputSurface_h
 #define FakeWebCompositorOutputSurface_h
 
+#include "base/memory/scoped_ptr.h"
 #include "FakeWebCompositorSoftwareOutputDevice.h"
 #include <public/WebCompositorOutputSurface.h>
 #include <public/WebGraphicsContext3D.h>
@@ -15,14 +16,14 @@ namespace WebKit {
 
 class FakeWebCompositorOutputSurface : public WebCompositorOutputSurface {
 public:
-    static inline PassOwnPtr<FakeWebCompositorOutputSurface> create(PassOwnPtr<WebGraphicsContext3D> context3D)
+    static inline scoped_ptr<FakeWebCompositorOutputSurface> create(PassOwnPtr<WebGraphicsContext3D> context3D)
     {
-        return adoptPtr(new FakeWebCompositorOutputSurface(context3D));
+        return scoped_ptr<FakeWebCompositorOutputSurface>(new FakeWebCompositorOutputSurface(context3D));
     }
 
-    static inline PassOwnPtr<FakeWebCompositorOutputSurface> createSoftware(PassOwnPtr<WebCompositorSoftwareOutputDevice> softwareDevice)
+    static inline scoped_ptr<FakeWebCompositorOutputSurface> createSoftware(PassOwnPtr<WebCompositorSoftwareOutputDevice> softwareDevice)
     {
-        return adoptPtr(new FakeWebCompositorOutputSurface(softwareDevice));
+        return scoped_ptr<FakeWebCompositorOutputSurface>(new FakeWebCompositorOutputSurface(softwareDevice));
     }
 
     virtual bool bindToClient(WebCompositorOutputSurfaceClient* client) OVERRIDE
diff --git a/webkit/compositor_bindings/WebLayerTreeViewImpl.cpp b/webkit/compositor_bindings/WebLayerTreeViewImpl.cpp
index 20e3d37..3bcca79 100644
--- a/webkit/compositor_bindings/WebLayerTreeViewImpl.cpp
+++ b/webkit/compositor_bindings/WebLayerTreeViewImpl.cpp
@@ -220,9 +220,9 @@ void WebLayerTreeViewImpl::applyScrollAndScale(const cc::IntSize& scrollDelta, f
     m_client->applyScrollAndScale(convert(scrollDelta), pageScale);
 }
 
-PassOwnPtr<WebCompositorOutputSurface> WebLayerTreeViewImpl::createOutputSurface()
+scoped_ptr<WebCompositorOutputSurface> WebLayerTreeViewImpl::createOutputSurface()
 {
-    return adoptPtr(m_client->createOutputSurface());
+    return scoped_ptr<WebCompositorOutputSurface>(m_client->createOutputSurface());
 }
 
 void WebLayerTreeViewImpl::didRecreateOutputSurface(bool success)
@@ -230,12 +230,13 @@ void WebLayerTreeViewImpl::didRecreateOutputSurface(bool success)
     m_client->didRecreateOutputSurface(success);
 }
 
-PassOwnPtr<CCInputHandler> WebLayerTreeViewImpl::createInputHandler()
+scoped_ptr<CCInputHandler> WebLayerTreeViewImpl::createInputHandler()
 {
+    scoped_ptr<CCInputHandler> ret;
     OwnPtr<WebInputHandler> handler = adoptPtr(m_client->createInputHandler());
     if (handler)
-        return WebToCCInputHandlerAdapter::create(handler.release());
-    return nullptr;
+        ret = WebToCCInputHandlerAdapter::create(handler.release());
+    return ret.Pass();
 }
 
 void WebLayerTreeViewImpl::willCommit()
diff --git a/webkit/compositor_bindings/WebLayerTreeViewImpl.h b/webkit/compositor_bindings/WebLayerTreeViewImpl.h
index 3dbeb20..77513e5 100644
--- a/webkit/compositor_bindings/WebLayerTreeViewImpl.h
+++ b/webkit/compositor_bindings/WebLayerTreeViewImpl.h
@@ -5,10 +5,10 @@
 #ifndef WebLayerTreeViewImpl_h
 #define WebLayerTreeViewImpl_h
 
+#include "base/memory/scoped_ptr.h"
 #include "CCLayerTreeHostClient.h"
 #include <public/WebLayerTreeView.h>
 #include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
 
 namespace cc {
 class CCLayerTreeHost;
@@ -57,9 +57,9 @@ public:
     virtual void animate(double monotonicFrameBeginTime) OVERRIDE;
     virtual void layout() OVERRIDE;
     virtual void applyScrollAndScale(const cc::IntSize& scrollDelta, float pageScale) OVERRIDE;
-    virtual PassOwnPtr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
+    virtual scoped_ptr<WebCompositorOutputSurface> createOutputSurface() OVERRIDE;
     virtual void didRecreateOutputSurface(bool success) OVERRIDE;
-    virtual PassOwnPtr<cc::CCInputHandler> createInputHandler() OVERRIDE;
+    virtual scoped_ptr<cc::CCInputHandler> createInputHandler() OVERRIDE;
     virtual void willCommit() OVERRIDE;
     virtual void didCommit() OVERRIDE;
     virtual void didCommitAndDrawFrame() OVERRIDE;
diff --git a/webkit/compositor_bindings/WebToCCInputHandlerAdapter.cpp b/webkit/compositor_bindings/WebToCCInputHandlerAdapter.cpp
index 89fb5ca..2ce8e4b 100644
--- a/webkit/compositor_bindings/WebToCCInputHandlerAdapter.cpp
+++ b/webkit/compositor_bindings/WebToCCInputHandlerAdapter.cpp
@@ -22,9 +22,9 @@ COMPILE_ASSERT_MATCHING_ENUM(WebInputHandlerClient::ScrollInputTypeWheel, CCInpu
 
 namespace WebKit {
 
-PassOwnPtr<WebToCCInputHandlerAdapter> WebToCCInputHandlerAdapter::create(PassOwnPtr<WebInputHandler> handler)
+scoped_ptr<WebToCCInputHandlerAdapter> WebToCCInputHandlerAdapter::create(PassOwnPtr<WebInputHandler> handler)
 {
-    return adoptPtr(new WebToCCInputHandlerAdapter(handler));
+    return scoped_ptr<WebToCCInputHandlerAdapter>(new WebToCCInputHandlerAdapter(handler));
 }
 
 WebToCCInputHandlerAdapter::WebToCCInputHandlerAdapter(PassOwnPtr<WebInputHandler> handler)
diff --git a/webkit/compositor_bindings/WebToCCInputHandlerAdapter.h b/webkit/compositor_bindings/WebToCCInputHandlerAdapter.h
index d04d34b..437c923 100644
--- a/webkit/compositor_bindings/WebToCCInputHandlerAdapter.h
+++ b/webkit/compositor_bindings/WebToCCInputHandlerAdapter.h
@@ -5,6 +5,7 @@
 #ifndef WebToCCInputHandlerAdapter_h
 #define WebToCCInputHandlerAdapter_h
 
+#include "base/memory/scoped_ptr.h"
 #include "CCInputHandler.h"
 #include <public/WebInputHandler.h>
 #include <wtf/OwnPtr.h>
@@ -14,7 +15,7 @@ namespace WebKit {
 
 class WebToCCInputHandlerAdapter : public cc::CCInputHandler {
 public:
-    static PassOwnPtr<WebToCCInputHandlerAdapter> create(PassOwnPtr<WebInputHandler>);
+    static scoped_ptr<WebToCCInputHandlerAdapter> create(PassOwnPtr<WebInputHandler>);
     virtual ~WebToCCInputHandlerAdapter();
 
     // cc::CCInputHandler implementation.
diff --git a/webkit/compositor_bindings/test/WebLayerTreeViewTestCommon.h b/webkit/compositor_bindings/test/WebLayerTreeViewTestCommon.h
index 2a81fb9..b3a5318 100644
--- a/webkit/compositor_bindings/test/WebLayerTreeViewTestCommon.h
+++ b/webkit/compositor_bindings/test/WebLayerTreeViewTestCommon.h
@@ -23,7 +23,7 @@ public:
 
     virtual WebCompositorOutputSurface* createOutputSurface() OVERRIDE
     {
-        return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes())).leakPtr();
+        return FakeWebCompositorOutputSurface::create(CompositorFakeWebGraphicsContext3D::create(WebGraphicsContext3D::Attributes())).release();
     }
     virtual void didRecreateOutputSurface(bool) OVERRIDE { }