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

third_party/WebKit/Source/bindings/core/v8/CallbackPromiseAdapter.h

 /*
  * 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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CallbackPromiseAdapter_h
 #define CallbackPromiseAdapter_h
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "public/platform/WebCallbacks.h"
-#include "public/platform/WebPassOwnPtr.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/TypeTraits.h"
 
+#include <memory>
+
 namespace blink {
 
 // CallbackPromiseAdapter is a WebCallbacks subclass and resolves / rejects the
 // stored resolver when onSuccess / onError is called, respectively.
 //
 // Basically CallbackPromiseAdapter<S, T> is a subclass of
 // WebCallbacks<S::WebType, T::WebType>. There are some exceptions:
 //  - If S or T don't have WebType (e.g. S = bool), a default WebType holder
 //    called trivial WebType holder is used. For example,
 //    CallbackPromiseAdapter<bool, void> is a subclass of
 //    WebCallbacks<bool, void>.
 //  - If a WebType is OwnPtr<T>, its corresponding type parameter on
-//    WebCallbacks is WebPassOwnPtr<T>, because WebCallbacks must be exposed to
+//    WebCallbacks is std::unique_ptr<T>, because WebCallbacks must be exposed to
 //    Chromium.
 //
 // When onSuccess is called with a S::WebType value, the value is passed to
 // S::take and the resolver is resolved with its return value. Ditto for
 // onError.
 //
 // ScriptPromiseResolver::resolve / reject will not be called when the execution
 // context is stopped.
 //
 // Example:
@@ skipping 10 matching lines @@
 // class MyErrorClass {
 // public:
 //     using WebType = const WebMyErrorClass&;
 //     static MyErrorClass take(ScriptPromiseResolver* resolver,
 //         const WebErrorClass& webError)
 //     {
 //         return MyErrorClass(webError);
 //     }
 //     ...
 // };
-// OwnPtr<WebCallbacks<WebPassOwnPtr<WebMyClass>, const WebMyErrorClass&>>
+// OwnPtr<WebCallbacks<std::unique_ptr<WebMyClass>, const WebMyErrorClass&>>
 //     callbacks = adoptPtr(new CallbackPromiseAdapter<MyClass, MyErrorClass>(
 //     resolver));
 // ...
 //
 // OwnPtr<WebCallbacks<bool, const WebMyErrorClass&>> callbacks2 =
 //     adoptPtr(new CallbackPromiseAdapter<bool, MyErrorClass>(resolver));
 // ...
 //
 //
 // In order to implement the above exceptions, we have template classes below.
@@ skipping 31 matching lines @@
     template <typename T>
     struct PassTypeImpl<OwnPtr<T>> {
         using Type = PassOwnPtr<T>;
     };
     template <typename T>
     struct WebPassTypeImpl {
         using Type = T;
     };
     template <typename T>
     struct WebPassTypeImpl<OwnPtr<T>> {
-        using Type = WebPassOwnPtr<T>;
+        using Type = std::unique_ptr<T>;
     };
     template <typename T> using PassType = typename PassTypeImpl<T>::Type;
     template <typename T> using WebPassType = typename WebPassTypeImpl<T>::Type;
     template <typename T> static T& adopt(T& x) { return x; }
-    template <typename T> static PassOwnPtr<T> adopt(WebPassOwnPtr<T>& x) { return x.release(); }
+    template <typename T>
+    static PassOwnPtr<T> adopt(std::unique_ptr<T>& x) { return adoptPtr(x.release()); }
     template <typename T> static PassType<T> pass(T& x) { return x; }
     template <typename T> static PassOwnPtr<T> pass(OwnPtr<T>& x) { return x.release(); }
 
     template <typename S, typename T>
     class Base : public WebCallbacks<WebPassType<typename S::WebType>, WebPassType<typename T::WebType>> {
     public:
         explicit Base(ScriptPromiseResolver* resolver) : m_resolver(resolver) {}
         ScriptPromiseResolver* resolver() { return m_resolver; }
 
     private:
@@ skipping 61 matching lines @@
 };
 
 } // namespace internal
 
 template <typename S, typename T>
 using CallbackPromiseAdapter = internal::CallbackPromiseAdapterInternal::CallbackPromiseAdapter<S, T>;
 
 } // namespace blink
 
 #endif