Remove OwnPtr from Blink.

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 "wtf/OwnPtr.h"
-#include "wtf/PassOwnPtr.h"
+#include "wtf/PtrUtil.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
+//  - If a WebType is std::unique_ptr<T>, its corresponding type parameter on
 //    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:
 // class MyClass {
 // public:
-//     using WebType = OwnPtr<WebMyClass>;
+//     using WebType = std::unique_ptr<WebMyClass>;
 //     static PassRefPtr<MyClass> take(ScriptPromiseResolver* resolver,
-//         PassOwnPtr<WebMyClass> webInstance)
+//         std::unique_ptr<WebMyClass> webInstance)
 //     {
 //         return MyClass::create(webInstance);
 //     }
 //     ...
 // };
 // class MyErrorClass {
 // public:
 //     using WebType = const WebMyErrorClass&;
 //     static MyErrorClass take(ScriptPromiseResolver* resolver,
 //         const WebErrorClass& webError)
 //     {
 //         return MyErrorClass(webError);
 //     }
 //     ...
 // };
-// OwnPtr<WebCallbacks<std::unique_ptr<WebMyClass>, const WebMyErrorClass&>>
-//     callbacks = adoptPtr(new CallbackPromiseAdapter<MyClass, MyErrorClass>(
+// std::unique_ptr<WebCallbacks<std::unique_ptr<WebMyClass>, const WebMyErrorClass&>>
+//     callbacks = wrapUnique(new CallbackPromiseAdapter<MyClass, MyErrorClass>(
 //     resolver));
 // ...
 //
-// OwnPtr<WebCallbacks<bool, const WebMyErrorClass&>> callbacks2 =
-//     adoptPtr(new CallbackPromiseAdapter<bool, MyErrorClass>(resolver));
+// std::unique_ptr<WebCallbacks<bool, const WebMyErrorClass&>> callbacks2 =
+//     wrapUnique(new CallbackPromiseAdapter<bool, MyErrorClass>(resolver));
 // ...
 //
 //
 // In order to implement the above exceptions, we have template classes below.
 // OnSuccess and OnError provide onSuccess and onError implementation, and there
 // are utility templates that provide
-//  - OwnPtr - WebPassOwnPtr translation ([Web]PassType[Impl], adopt, pass),
+//  - std::unique_ptr - WebPassOwnPtr translation ([Web]PassType[Impl], adopt, pass),
 //  - trivial WebType holder (TrivialWebTypeHolder).
 
 namespace internal {
 
 // This template is placed outside of CallbackPromiseAdapterInternal because
 // explicit specialization is forbidden in a class scope.
 template <typename T>
 struct CallbackPromiseAdapterTrivialWebTypeHolder {
     using WebType = T;
     static T take(ScriptPromiseResolver*, const T& x) { return x; }
 };
 template <>
 struct CallbackPromiseAdapterTrivialWebTypeHolder<void> {
     using WebType = void;
 };
 
 class CallbackPromiseAdapterInternal {
 private:
     template <typename T> static T webTypeHolderMatcher(typename std::remove_reference<typename T::WebType>::type*);
     template <typename T> static CallbackPromiseAdapterTrivialWebTypeHolder<T> webTypeHolderMatcher(...);
     template <typename T> using WebTypeHolder = decltype(webTypeHolderMatcher<T>(nullptr));
 
     // The following templates should be gone when the repositories are merged
     // and we can use C++11 libraries.
     template <typename T>
     struct PassTypeImpl {
         using Type = T;
     };
     template <typename T>
-    struct PassTypeImpl<OwnPtr<T>> {
-        using Type = PassOwnPtr<T>;
+    struct PassTypeImpl<std::unique_ptr<T>> {
+        using Type = std::unique_ptr<T>;
     };
     template <typename T>
     struct WebPassTypeImpl {
         using Type = T;
     };
     template <typename T>
-    struct WebPassTypeImpl<OwnPtr<T>> {
+    struct WebPassTypeImpl<std::unique_ptr<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(std::unique_ptr<T>& x) { return adoptPtr(x.release()); }
+    static std::unique_ptr<T> adopt(std::unique_ptr<T>& x) { return wrapUnique(x.release()); }

[tkent, 2016/06/14 02:23:47]

Should wrapUnique and .release() here be std:move()?

[Yuta Kitamura, 2016/06/14 04:44:44]

Yeah, that's weird. I'm going to fix this in the
next merge cycle.

     template <typename T> static PassType<T> pass(T& x) { return x; }
-    template <typename T> static PassOwnPtr<T> pass(OwnPtr<T>& x) { return std::move(x); }
+    template <typename T> static std::unique_ptr<T> pass(std::unique_ptr<T>& x) { return std::move(x); }
 
     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:
         Persistent<ScriptPromiseResolver> m_resolver;
     };
@@ skipping 59 matching lines @@
 };
 
 } // namespace internal
 
 template <typename S, typename T>
 using CallbackPromiseAdapter = internal::CallbackPromiseAdapterInternal::CallbackPromiseAdapter<S, T>;
 
 } // namespace blink
 
 #endif