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

third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 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:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 70 matching lines @@
 #include "public/platform/WebRTCDataChannelHandler.h"
 #include "public/platform/WebRTCDataChannelInit.h"
 #include "public/platform/WebRTCICECandidate.h"
 #include "public/platform/WebRTCKeyParams.h"
 #include "public/platform/WebRTCOfferOptions.h"
 #include "public/platform/WebRTCSessionDescription.h"
 #include "public/platform/WebRTCSessionDescriptionRequest.h"
 #include "public/platform/WebRTCStatsRequest.h"
 #include "public/platform/WebRTCVoidRequest.h"
 
+#include <memory>
+
 namespace blink {
 
 namespace {
 
 const char kSignalingStateClosedMessage[] = "The RTCPeerConnection's signalingState is 'closed'.";
 
 bool throwExceptionIfSignalingStateClosed(RTCPeerConnection::SignalingState state, ExceptionState& exceptionState)
 {
     if (state == RTCPeerConnection::SignalingStateClosed) {
         exceptionState.throwDOMException(InvalidStateError, kSignalingStateClosedMessage);
@@ skipping 61 matching lines @@
 class WebRTCCertificateObserver : public WebRTCCertificateCallback {
 public:
     // Takes ownership of |resolver|.
     static WebRTCCertificateObserver* create(ScriptPromiseResolver* resolver)
     {
         return new WebRTCCertificateObserver(resolver);
     }
 
     ~WebRTCCertificateObserver() override {}
 
-    DEFINE_INLINE_TRACE() { visitor->trace(m_resolver); }
-
 private:
     WebRTCCertificateObserver(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) {}
 
-    void onSuccess(WebPassOwnPtr<WebRTCCertificate> certificate) override
+    void onSuccess(std::unique_ptr<WebRTCCertificate> certificate) override
     {
-        m_resolver->resolve(new RTCCertificate(certificate));
+        m_resolver->resolve(new RTCCertificate(std::move(certificate)));
     }
 
     void onError() override
     {
         m_resolver->reject();
     }
 
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
@@ skipping 507 matching lines @@
         Platform::current()->createRTCCertificateGenerator());
 
     // |keyParams| was successfully constructed, but does the certificate generator support these parameters?
     if (!certificateGenerator->isSupportedKeyParams(keyParams.get())) {
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, unsupportedParamsString));
     }
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
-    WebPassOwnPtr<WebRTCCertificateObserver> certificateObserver = adoptWebPtr(WebRTCCertificateObserver::create(resolver));
+    std::unique_ptr<WebRTCCertificateObserver> certificateObserver(WebRTCCertificateObserver::create(resolver));
 
     // Generate certificate. The |certificateObserver| will resolve the promise asynchronously upon completion.
     // The observer will manage its own destruction as well as the resolver's destruction.
     certificateGenerator->generateCertificate(
         keyParams.get(),
         toDocument(scriptState->getExecutionContext())->url(),
         toDocument(scriptState->getExecutionContext())->firstPartyForCookies(),
-        certificateObserver);
+        std::move(certificateObserver));
 
     return promise;
 }
 
 ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, const RTCIceCandidateInitOrRTCIceCandidate& candidate)
 {
     if (m_signalingState == SignalingStateClosed)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
     if (isIceCandidateMissingSdp(candidate))
@@ skipping 439 matching lines @@
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dispatchScheduledEventRunner);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink