Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/TimerTest.cpp

 // Copyright 2015 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/Timer.h"
 
 #include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebViewScheduler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/RefCounted.h"
+#include <memory>
 #include <queue>
 
 using testing::ElementsAre;
 
 namespace blink {
 namespace {
 double gCurrentTimeSecs = 0.0;
 
-// This class exists because gcc doesn't know how to move an OwnPtr.
+// This class exists because gcc doesn't know how to move an std::unique_ptr.
 class RefCountedTaskContainer : public RefCounted<RefCountedTaskContainer> {
 public:
-    explicit RefCountedTaskContainer(WebTaskRunner::Task* task) : m_task(adoptPtr(task)) { }
+    explicit RefCountedTaskContainer(WebTaskRunner::Task* task) : m_task(wrapUnique(task)) { }
 
     ~RefCountedTaskContainer() { }
 
     void run()
     {
         m_task->run();
     }
 
 private:
-    OwnPtr<WebTaskRunner::Task> m_task;
+    std::unique_ptr<WebTaskRunner::Task> m_task;
 };
 
 class DelayedTask {
 public:
     DelayedTask(WebTaskRunner::Task* task, double delaySeconds)
         : m_task(adoptRef(new RefCountedTaskContainer(task)))
         , m_runTimeSeconds(gCurrentTimeSecs + delaySeconds)
         , m_delaySeconds(delaySeconds)
     {
     }
@@ skipping 146 matching lines @@
     void removePendingNavigation(WebScheduler::NavigatingFrameType) override { }
     void onNavigationStarted() override { }
 
 private:
     std::priority_queue<DelayedTask> m_timerTasks;
     MockWebTaskRunner m_timerWebTaskRunner;
 };
 
 class FakeWebThread : public WebThread {
 public:
-    FakeWebThread() : m_webScheduler(adoptPtr(new MockWebScheduler())) { }
+    FakeWebThread() : m_webScheduler(wrapUnique(new MockWebScheduler())) { }
     ~FakeWebThread() override { }
 
     virtual bool isCurrentThread() const
     {
         ASSERT_NOT_REACHED();
         return true;
     }
 
     virtual PlatformThreadId threadId() const
     {
@@ skipping 16 matching lines @@
     {
         ASSERT_NOT_REACHED();
     }
 
     virtual void exitRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
 private:
-    OwnPtr<MockWebScheduler> m_webScheduler;
+    std::unique_ptr<MockWebScheduler> m_webScheduler;
 };
 
 class TimerTestPlatform : public TestingPlatformSupport {
 public:
     TimerTestPlatform()
-        : m_webThread(adoptPtr(new FakeWebThread())) { }
+        : m_webThread(wrapUnique(new FakeWebThread())) { }
     ~TimerTestPlatform() override { }
 
     WebThread* currentThread() override
     {
         return m_webThread.get();
     }
 
     void runUntilIdle()
     {
         mockScheduler()->runUntilIdle();
@@ skipping 18 matching lines @@
     {
         return mockScheduler()->nextTimerTaskDelaySecs();
     }
 
 private:
     MockWebScheduler* mockScheduler() const
     {
         return static_cast<MockWebScheduler*>(m_webThread->scheduler());
     }
 
-    OwnPtr<FakeWebThread> m_webThread;
+    std::unique_ptr<FakeWebThread> m_webThread;
 };
 
 class TimerTest : public testing::Test {
 public:
     void SetUp() override
     {
         m_runTimes.clear();
         gCurrentTimeSecs = 10.0;
         m_startTime = gCurrentTimeSecs;
     }
@@ skipping 480 matching lines @@
     TimerForTest<TimerTest> timer(this, &TimerTest::countingTask, &taskRunner);
     timer.startOneShot(0, BLINK_FROM_HERE);
 
     // Make sure the task was posted on taskRunner.
     EXPECT_FALSE(timerTasks.empty());
 }
 
 
 } // namespace
 } // namespace blink