Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurfaceTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/RecordingImageBufferSurface.h"
 
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageBufferClient.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
+#include <memory>
 
 using testing::Test;
 
 namespace blink {
 
 class FakeImageBufferClient : public ImageBufferClient, public WebThread::TaskObserver {
 public:
     FakeImageBufferClient(ImageBuffer* imageBuffer)
         : m_isDirty(false)
         , m_imageBuffer(imageBuffer)
@@ skipping 38 matching lines @@
 private:
     bool m_isDirty;
     ImageBuffer* m_imageBuffer;
     int m_frameCount;
 };
 
 class MockSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
 public:
     MockSurfaceFactory() : m_createSurfaceCount(0) { }
 
-    virtual PassOwnPtr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode opacityMode)
+    virtual std::unique_ptr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode opacityMode)
     {
         m_createSurfaceCount++;
-        return adoptPtr(new UnacceleratedImageBufferSurface(size, opacityMode));
+        return wrapUnique(new UnacceleratedImageBufferSurface(size, opacityMode));
     }
 
     virtual ~MockSurfaceFactory() { }
 
     int createSurfaceCount() { return m_createSurfaceCount; }
 
 private:
     int m_createSurfaceCount;
 };
 
 class RecordingImageBufferSurfaceTest : public Test {
 protected:
     RecordingImageBufferSurfaceTest()
     {
-        OwnPtr<MockSurfaceFactory> surfaceFactory = adoptPtr(new MockSurfaceFactory());
+        std::unique_ptr<MockSurfaceFactory> surfaceFactory = wrapUnique(new MockSurfaceFactory());
         m_surfaceFactory = surfaceFactory.get();
-        OwnPtr<RecordingImageBufferSurface> testSurface = adoptPtr(new RecordingImageBufferSurface(IntSize(10, 10), std::move(surfaceFactory)));
+        std::unique_ptr<RecordingImageBufferSurface> testSurface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), std::move(surfaceFactory)));
         m_testSurface = testSurface.get();
         // We create an ImageBuffer in order for the testSurface to be
         // properly initialized with a GraphicsContext
         m_imageBuffer = ImageBuffer::create(std::move(testSurface));
         EXPECT_FALSE(!m_imageBuffer);
-        m_fakeImageBufferClient = adoptPtr(new FakeImageBufferClient(m_imageBuffer.get()));
+        m_fakeImageBufferClient = wrapUnique(new FakeImageBufferClient(m_imageBuffer.get()));
         m_imageBuffer->setClient(m_fakeImageBufferClient.get());
     }
 
 public:
     void testEmptyPicture()
     {
         m_testSurface->initializeCurrentFrame();
         RefPtr<SkPicture> picture = m_testSurface->getPicture();
         EXPECT_TRUE((bool)picture.get());
         EXPECT_EQ(1, m_fakeImageBufferClient->frameCount());
@@ skipping 101 matching lines @@
     {
         EXPECT_EQ(displayListEnabled, (bool)m_testSurface->m_currentFrame.get());
         EXPECT_EQ(!displayListEnabled, (bool)m_testSurface->m_fallbackSurface.get());
         int expectedSurfaceCreationCount = displayListEnabled ? 0 : 1;
         EXPECT_EQ(expectedSurfaceCreationCount, m_surfaceFactory->createSurfaceCount());
     }
 
 private:
     MockSurfaceFactory* m_surfaceFactory;
     RecordingImageBufferSurface* m_testSurface;
-    OwnPtr<FakeImageBufferClient> m_fakeImageBufferClient;
-    OwnPtr<ImageBuffer> m_imageBuffer;
+    std::unique_ptr<FakeImageBufferClient> m_fakeImageBufferClient;
+    std::unique_ptr<ImageBuffer> m_imageBuffer;
 };
 
 namespace {
 
 // The following test helper class installs a mock platform that provides a mock WebThread
 // for the current thread. The Mock thread is capable of queuing a single non-delayed task
 // and registering a single task observer. The run loop exits immediately after running
 // the single task.
 
 class CurrentThreadPlatformMock : public TestingPlatformSupport {
@@ skipping 143 matching lines @@
     expectDisplayListEnabled(true);
 }
 
 TEST_F(RecordingImageBufferSurfaceTest, testClearRect)
 {
     CALL_TEST_TASK_WRAPPER(testClearRect);
     expectDisplayListEnabled(true);
 }
 
 } // namespace blink