Remove OwnPtr from Blink.

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp

 // Copyright 2016 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 "core/loader/ThreadableLoader.h"
 
 #include "core/dom/CrossThreadTask.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/DocumentThreadableLoader.h"
@@ skipping 12 matching lines @@
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURLLoadTiming.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Assertions.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
+#include <memory>
 
 namespace blink {
 
 namespace {
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::StrEq;
 using ::testing::Truly;
 using Checkpoint = ::testing::StrictMock<::testing::MockFunction<void(int)>>;
 
 class MockThreadableLoaderClient : public ThreadableLoaderClient {
 public:
-    static PassOwnPtr<MockThreadableLoaderClient> create()
+    static std::unique_ptr<MockThreadableLoaderClient> create()
     {
-        return adoptPtr(new ::testing::StrictMock<MockThreadableLoaderClient>);
+        return wrapUnique(new ::testing::StrictMock<MockThreadableLoaderClient>);
     }
     MOCK_METHOD2(didSendData, void(unsigned long long, unsigned long long));
     MOCK_METHOD3(didReceiveResponseMock, void(unsigned long, const ResourceResponse&, WebDataConsumerHandle*));
-    void didReceiveResponse(unsigned long identifier, const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
+    void didReceiveResponse(unsigned long identifier, const ResourceResponse& response, std::unique_ptr<WebDataConsumerHandle> handle)
     {
         didReceiveResponseMock(identifier, response, handle.get());
     }
     MOCK_METHOD2(didReceiveData, void(const char*, unsigned));
     MOCK_METHOD2(didReceiveCachedMetadata, void(const char*, int));
     MOCK_METHOD2(didFinishLoading, void(unsigned long, double));
     MOCK_METHOD1(didFail, void(const ResourceError&));
     MOCK_METHOD1(didFailAccessControlCheck, void(const ResourceError&));
     MOCK_METHOD0(didFailRedirectCheck, void());
     MOCK_METHOD1(didReceiveResourceTiming, void(const ResourceTimingInfo&));
@@ skipping 72 matching lines @@
     }
 
     void onTearDown() override
     {
         m_loader.reset();
     }
 
 private:
     Document& document() { return m_dummyPageHolder->document(); }
 
-    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Checkpoint m_checkpoint;
-    OwnPtr<DocumentThreadableLoader> m_loader;
+    std::unique_ptr<DocumentThreadableLoader> m_loader;
 };
 
 class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper, public WorkerLoaderProxyProvider {
 public:
     WorkerThreadableLoaderTestHelper()
         : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1)))
     {
     }
 
     void createLoader(ThreadableLoaderClient* client, CrossOriginRequestPolicy crossOriginRequestPolicy) override
     {
-        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        std::unique_ptr<WaitableEvent> completionEvent = wrapUnique(new WaitableEvent());
         postTaskToWorkerGlobalScope(createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCreateLoader,
             AllowCrossThreadAccess(this),
             AllowCrossThreadAccess(client),
             AllowCrossThreadAccess(completionEvent.get()),
             crossOriginRequestPolicy));
         completionEvent->wait();
     }
 
     void startLoader(const ResourceRequest& request) override
     {
-        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        std::unique_ptr<WaitableEvent> completionEvent = wrapUnique(new WaitableEvent());
         postTaskToWorkerGlobalScope(createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerStartLoader,
             AllowCrossThreadAccess(this),
             AllowCrossThreadAccess(completionEvent.get()),
             request));
         completionEvent->wait();
     }
 
     // Must be called on the worker thread.
     void cancelLoader() override
@@ skipping 13 matching lines @@
 
     Checkpoint& checkpoint() override
     {
         return m_checkpoint;
     }
 
     void callCheckpoint(int n) override
     {
         testing::runPendingTasks();
 
-        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        std::unique_ptr<WaitableEvent> completionEvent = wrapUnique(new WaitableEvent());
         postTaskToWorkerGlobalScope(createCrossThreadTask(
             &WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
             AllowCrossThreadAccess(this),
             AllowCrossThreadAccess(completionEvent.get()),
             n));
         completionEvent->wait();
     }
 
     void onSetUp() override
     {
-        m_mockWorkerReportingProxy = adoptPtr(new MockWorkerReportingProxy());
+        m_mockWorkerReportingProxy = wrapUnique(new MockWorkerReportingProxy());
         m_securityOrigin = document().getSecurityOrigin();
-        m_workerThread = adoptPtr(new WorkerThreadForTest(
+        m_workerThread = wrapUnique(new WorkerThreadForTest(
             this,
             *m_mockWorkerReportingProxy));
 
         expectWorkerLifetimeReportingCalls();
         m_workerThread->startWithSourceCode(m_securityOrigin.get(), "//fake source code");
         m_workerThread->waitForInit();
     }
 
     void onServeRequests() override
     {
@@ skipping 36 matching lines @@
         // ThreadableLoader::create() determines whether it should create
         // a DocumentThreadableLoader or WorkerThreadableLoader based on
         // isWorkerGlobalScope().
         ASSERT(m_workerThread->workerGlobalScope()->isWorkerGlobalScope());
 
         m_loader = ThreadableLoader::create(*m_workerThread->workerGlobalScope(), client, options, resourceLoaderOptions);
         ASSERT(m_loader);
         event->signal();
     }
 
-    void workerStartLoader(WaitableEvent* event, PassOwnPtr<CrossThreadResourceRequestData> requestData)
+    void workerStartLoader(WaitableEvent* event, std::unique_ptr<CrossThreadResourceRequestData> requestData)
     {
         ASSERT(m_workerThread);
         ASSERT(m_workerThread->isCurrentThread());
 
         ResourceRequest request(requestData.get());
         m_loader->start(request);
         event->signal();
     }
 
     void workerCallCheckpoint(WaitableEvent* event, int n)
@@ skipping 13 matching lines @@
     }
 
     bool postTaskToWorkerGlobalScope(std::unique_ptr<ExecutionContextTask> task) override
     {
         ASSERT(m_workerThread);
         m_workerThread->postTask(BLINK_FROM_HERE, std::move(task));
         return true;
     }
 
     RefPtr<SecurityOrigin> m_securityOrigin;
-    OwnPtr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
-    OwnPtr<WorkerThreadForTest> m_workerThread;
+    std::unique_ptr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
+    std::unique_ptr<WorkerThreadForTest> m_workerThread;
 
-    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Checkpoint m_checkpoint;
     // |m_loader| must be touched only from the worker thread only.
-    OwnPtr<ThreadableLoader> m_loader;
+    std::unique_ptr<ThreadableLoader> m_loader;
 };
 
 class ThreadableLoaderTest : public ::testing::TestWithParam<ThreadableLoaderToTest> {
 public:
     ThreadableLoaderTest()
     {
         switch (GetParam()) {
         case DocumentThreadableLoaderTest:
-            m_helper = adoptPtr(new DocumentThreadableLoaderTestHelper);
+            m_helper = wrapUnique(new DocumentThreadableLoaderTestHelper);
             break;
         case WorkerThreadableLoaderTest:
-            m_helper = adoptPtr(new WorkerThreadableLoaderTestHelper);
+            m_helper = wrapUnique(new WorkerThreadableLoaderTestHelper);
             break;
         }
     }
 
     void startLoader(const KURL& url)
     {
         ResourceRequest request(url);
         request.setRequestContext(WebURLRequest::RequestContextObject);
         m_helper->startLoader(request);
     }
@@ skipping 75 matching lines @@
         response.initialize();
         response.setURL(url);
         response.setHTTPStatusCode(301);
         response.setLoadTiming(timing);
         response.addHTTPHeaderField("Location", redirectLoopURL().getString());
         response.addHTTPHeaderField("Access-Control-Allow-Origin", "null");
 
         URLTestHelpers::registerMockedURLLoadWithCustomResponse(url, "fox-null-terminated.html", "", response);
     }
 
-    OwnPtr<MockThreadableLoaderClient> m_client;
-    OwnPtr<ThreadableLoaderTestHelper> m_helper;
+    std::unique_ptr<MockThreadableLoaderClient> m_client;
+    std::unique_ptr<ThreadableLoaderTestHelper> m_helper;
 };
 
 INSTANTIATE_TEST_CASE_P(Document,
     ThreadableLoaderTest,
     ::testing::Values(DocumentThreadableLoaderTest));
 
 INSTANTIATE_TEST_CASE_P(Worker,
     ThreadableLoaderTest,
     ::testing::Values(WorkerThreadableLoaderTest));
 
@@ skipping 394 matching lines @@
     EXPECT_CALL(*client(), didFailRedirectCheck()).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
 
     startLoader(redirectLoopURL());
     callCheckpoint(2);
     serveRequests();
 }
 
 } // namespace
 
 } // namespace blink