Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerContainerTest.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 "modules/serviceworkers/ServiceWorkerContainer.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/page/FocusController.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/serviceworkers/ServiceWorkerContainerClient.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerClientsInfo.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerProvider.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/text/WTFString.h"
+#include <memory>
 #include <v8.h>
 
 namespace blink {
 namespace {
 
 // Promise-related test support.
 
 struct StubScriptFunction {
 public:
     StubScriptFunction()
@@ skipping 116 matching lines @@
     ~ServiceWorkerContainerTest()
     {
         m_page.reset();
         V8GCController::collectAllGarbageForTesting(isolate());
     }
 
     ExecutionContext* getExecutionContext() { return &(m_page->document()); }
     v8::Isolate* isolate() { return v8::Isolate::GetCurrent(); }
     ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
 
-    void provide(PassOwnPtr<WebServiceWorkerProvider> provider)
+    void provide(std::unique_ptr<WebServiceWorkerProvider> provider)
     {
         Supplement<Document>::provideTo(m_page->document(), ServiceWorkerContainerClient::supplementName(), ServiceWorkerContainerClient::create(std::move(provider)));
     }
 
     void setPageURL(const String& url)
     {
         // For URL completion.
         m_page->document().setURL(KURL(KURL(), url));
 
         // The basis for security checks.
         m_page->document().setSecurityOrigin(SecurityOrigin::createFromString(url));
     }
 
     void testRegisterRejected(const String& scriptURL, const String& scope, const ScriptValueTest& valueTest)
     {
         // When the registration is rejected, a register call must not reach
         // the provider.
-        provide(adoptPtr(new NotReachedWebServiceWorkerProvider()));
+        provide(wrapUnique(new NotReachedWebServiceWorkerProvider()));
 
         ServiceWorkerContainer* container = ServiceWorkerContainer::create(getExecutionContext());
         ScriptState::Scope scriptScope(getScriptState());
         RegistrationOptions options;
         options.setScope(scope);
         ScriptPromise promise = container->registerServiceWorker(getScriptState(), scriptURL, options);
         expectRejected(getScriptState(), promise, valueTest);
 
         container->willBeDetachedFromFrame();
     }
 
     void testGetRegistrationRejected(const String& documentURL, const ScriptValueTest& valueTest)
     {
-        provide(adoptPtr(new NotReachedWebServiceWorkerProvider()));
+        provide(wrapUnique(new NotReachedWebServiceWorkerProvider()));
 
         ServiceWorkerContainer* container = ServiceWorkerContainer::create(getExecutionContext());
         ScriptState::Scope scriptScope(getScriptState());
         ScriptPromise promise = container->getRegistration(getScriptState(), documentURL);
         expectRejected(getScriptState(), promise, valueTest);
 
         container->willBeDetachedFromFrame();
     }
 
 private:
-    OwnPtr<DummyPageHolder> m_page;
+    std::unique_ptr<DummyPageHolder> m_page;
 };
 
 TEST_F(ServiceWorkerContainerTest, Register_NonSecureOriginIsRejected)
 {
     setPageURL("http://www.example.com/");
     testRegisterRejected(
         "http://www.example.com/worker.js",
         "http://www.example.com/",
         ExpectDOMException("SecurityError", "Only secure origins are allowed (see: https://goo.gl/Y0ZkNV)."));
 }
@@ skipping 37 matching lines @@
     StubWebServiceWorkerProvider()
         : m_registerCallCount(0)
         , m_getRegistrationCallCount(0)
     {
     }
 
     // Creates a WebServiceWorkerProvider. This can outlive the
     // StubWebServiceWorkerProvider, but |registerServiceWorker| and
     // other methods must not be called after the
     // StubWebServiceWorkerProvider dies.
-    PassOwnPtr<WebServiceWorkerProvider> provider()
+    std::unique_ptr<WebServiceWorkerProvider> provider()
     {
-        return adoptPtr(new WebServiceWorkerProviderImpl(*this));
+        return wrapUnique(new WebServiceWorkerProviderImpl(*this));
     }
 
     size_t registerCallCount() { return m_registerCallCount; }
     const WebURL& registerScope() { return m_registerScope; }
     const WebURL& registerScriptURL() { return m_registerScriptURL; }
     size_t getRegistrationCallCount() { return m_getRegistrationCallCount; }
     const WebURL& getRegistrationURL() { return m_getRegistrationURL; }
 
 private:
     class WebServiceWorkerProviderImpl : public WebServiceWorkerProvider {
     public:
         WebServiceWorkerProviderImpl(StubWebServiceWorkerProvider& owner)
             : m_owner(owner)
         {
         }
 
         ~WebServiceWorkerProviderImpl() override { }
 
         void registerServiceWorker(const WebURL& pattern, const WebURL& scriptURL, WebServiceWorkerRegistrationCallbacks* callbacks) override
         {
             m_owner.m_registerCallCount++;
             m_owner.m_registerScope = pattern;
             m_owner.m_registerScriptURL = scriptURL;
-            m_registrationCallbacksToDelete.append(adoptPtr(callbacks));
+            m_registrationCallbacksToDelete.append(wrapUnique(callbacks));
         }
 
         void getRegistration(const WebURL& documentURL, WebServiceWorkerGetRegistrationCallbacks* callbacks) override
         {
             m_owner.m_getRegistrationCallCount++;
             m_owner.m_getRegistrationURL = documentURL;
-            m_getRegistrationCallbacksToDelete.append(adoptPtr(callbacks));
+            m_getRegistrationCallbacksToDelete.append(wrapUnique(callbacks));
         }
 
         bool validateScopeAndScriptURL(const WebURL& scope, const WebURL& scriptURL, WebString* errorMessage)
         {
             return true;
         }
 
     private:
         StubWebServiceWorkerProvider& m_owner;
-        Vector<OwnPtr<WebServiceWorkerRegistrationCallbacks>> m_registrationCallbacksToDelete;
-        Vector<OwnPtr<WebServiceWorkerGetRegistrationCallbacks>> m_getRegistrationCallbacksToDelete;
+        Vector<std::unique_ptr<WebServiceWorkerRegistrationCallbacks>> m_registrationCallbacksToDelete;
+        Vector<std::unique_ptr<WebServiceWorkerGetRegistrationCallbacks>> m_getRegistrationCallbacksToDelete;
     };
 
 private:
     size_t m_registerCallCount;
     WebURL m_registerScope;
     WebURL m_registerScriptURL;
     size_t m_getRegistrationCallCount;
     WebURL m_getRegistrationURL;
 };
 
@@ skipping 35 matching lines @@
         container->getRegistration(getScriptState(), "");
         EXPECT_EQ(1ul, stubProvider.getRegistrationCallCount());
         EXPECT_EQ(WebURL(KURL(KURL(), "http://localhost/x/index.html")), stubProvider.getRegistrationURL());
     }
 
     container->willBeDetachedFromFrame();
 }
 
 } // namespace
 } // namespace blink