Nuke WebPassOwnPtr<T> and replace it with std::unique_ptr<T>.

third_party/WebKit/Source/modules/serviceworkers/ServiceWorkerContainer.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 46 matching lines @@
 #include "public/platform/modules/serviceworker/WebServiceWorkerRegistration.h"
 
 namespace blink {
 
 class RegistrationCallback : public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
 public:
     explicit RegistrationCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~RegistrationCallback() override { }
 
-    void onSuccess(WebPassOwnPtr<WebServiceWorkerRegistration::Handle> handle) override
+    void onSuccess(std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(m_resolver->getExecutionContext(), handle.release()));
+        m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(m_resolver->getExecutionContext(), adoptPtr(handle.release())));
     }
 
     void onError(const WebServiceWorkerError& error) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         if (error.errorType == WebServiceWorkerError::ErrorTypeType) {
             m_resolver->reject(V8ThrowException::createTypeError(m_resolver->getScriptState()->isolate(), error.message));
         } else {
             m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
         }
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(RegistrationCallback);
 };
 
 class GetRegistrationCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationCallbacks {
 public:
     explicit GetRegistrationCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~GetRegistrationCallback() override { }
 
-    void onSuccess(WebPassOwnPtr<WebServiceWorkerRegistration::Handle> webPassHandle) override
+    void onSuccess(std::unique_ptr<WebServiceWorkerRegistration::Handle> webPassHandle) override
     {
-        OwnPtr<WebServiceWorkerRegistration::Handle> handle = webPassHandle.release();
+        OwnPtr<WebServiceWorkerRegistration::Handle> handle = adoptPtr(webPassHandle.release());
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         if (!handle) {
             // Resolve the promise with undefined.
             m_resolver->resolve();
             return;
         }
         m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(m_resolver->getExecutionContext(), handle.release()));
     }
 
     void onError(const WebServiceWorkerError& error) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
 };
 
 class GetRegistrationsCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationsCallbacks {
 public:
     explicit GetRegistrationsCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~GetRegistrationsCallback() override { }
 
-    void onSuccess(WebPassOwnPtr<WebVector<WebServiceWorkerRegistration::Handle*>> webPassRegistrations) override
+    void onSuccess(std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>> webPassRegistrations) override
     {
         Vector<OwnPtr<WebServiceWorkerRegistration::Handle>> handles;
-        OwnPtr<WebVector<WebServiceWorkerRegistration::Handle*>> webRegistrations = webPassRegistrations.release();
+        OwnPtr<WebVector<WebServiceWorkerRegistration::Handle*>> webRegistrations = adoptPtr(webPassRegistrations.release());
         for (auto& handle : *webRegistrations) {
             handles.append(adoptPtr(handle));
         }
 
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->resolve(ServiceWorkerRegistrationArray::take(m_resolver.get(), &handles));
     }
 
     void onError(const WebServiceWorkerError& error) override
     {
         if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(GetRegistrationsCallback);
 };
 
 class ServiceWorkerContainer::GetRegistrationForReadyCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationForReadyCallbacks {
 public:
     explicit GetRegistrationForReadyCallback(ReadyProperty* ready)
         : m_ready(ready) { }
     ~GetRegistrationForReadyCallback() override { }
 
-    void onSuccess(WebPassOwnPtr<WebServiceWorkerRegistration::Handle> handle) override
+    void onSuccess(std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override
     {
         ASSERT(m_ready->getState() == ReadyProperty::Pending);
 
         if (m_ready->getExecutionContext() && !m_ready->getExecutionContext()->activeDOMObjectsAreStopped())
-            m_ready->resolve(ServiceWorkerRegistration::getOrCreate(m_ready->getExecutionContext(), handle.release()));
+            m_ready->resolve(ServiceWorkerRegistration::getOrCreate(m_ready->getExecutionContext(), adoptPtr(handle.release())));
     }
 
 private:
     Persistent<ReadyProperty> m_ready;
     WTF_MAKE_NONCOPYABLE(GetRegistrationForReadyCallback);
 };
 
 ServiceWorkerContainer* ServiceWorkerContainer::create(ExecutionContext* executionContext)
 {
     return new ServiceWorkerContainer(executionContext);
@@ skipping 191 matching lines @@
 
     if (!m_ready) {
         m_ready = createReadyProperty();
         if (m_provider)
             m_provider->getRegistrationForReady(new GetRegistrationForReadyCallback(m_ready.get()));
     }
 
     return m_ready->promise(callerState->world());
 }
 
-void ServiceWorkerContainer::setController(WebPassOwnPtr<WebServiceWorker::Handle> handle, bool shouldNotifyControllerChange)
+void ServiceWorkerContainer::setController(std::unique_ptr<WebServiceWorker::Handle> handle, bool shouldNotifyControllerChange)
 {
     if (!getExecutionContext())
         return;
-    m_controller = ServiceWorker::from(getExecutionContext(), handle.release());
+    m_controller = ServiceWorker::from(getExecutionContext(), adoptPtr(handle.release()));
     if (m_controller)
         UseCounter::count(getExecutionContext(), UseCounter::ServiceWorkerControlledPage);
     if (shouldNotifyControllerChange)
         dispatchEvent(Event::create(EventTypeNames::controllerchange));
 }
 
-void ServiceWorkerContainer::dispatchMessageEvent(WebPassOwnPtr<WebServiceWorker::Handle> handle, const WebString& message, const WebMessagePortChannelArray& webChannels)
+void ServiceWorkerContainer::dispatchMessageEvent(std::unique_ptr<WebServiceWorker::Handle> handle, const WebString& message, const WebMessagePortChannelArray& webChannels)
 {
     if (!getExecutionContext() || !getExecutionContext()->executingWindow())
         return;
 
     MessagePortArray* ports = MessagePort::toMessagePortArray(getExecutionContext(), webChannels);
     RefPtr<SerializedScriptValue> value = SerializedScriptValueFactory::instance().createFromWire(message);
-    ServiceWorker* source = ServiceWorker::from(getExecutionContext(), handle.release());
+    ServiceWorker* source = ServiceWorker::from(getExecutionContext(), adoptPtr(handle.release()));
     dispatchEvent(ServiceWorkerMessageEvent::create(ports, value, source, getExecutionContext()->getSecurityOrigin()->toString()));
 }
 
 const AtomicString& ServiceWorkerContainer::interfaceName() const
 {
     return EventTargetNames::ServiceWorkerContainer;
 }
 
 ServiceWorkerContainer::ServiceWorkerContainer(ExecutionContext* executionContext)
     : ContextLifecycleObserver(executionContext)
     , m_provider(0)
 {
 
     if (!executionContext)
         return;
 
     if (ServiceWorkerContainerClient* client = ServiceWorkerContainerClient::from(executionContext)) {
         m_provider = client->provider();
         if (m_provider)
             m_provider->setClient(this);
     }
 }
 
 } // namespace blink