CallbackPromiseAdapter cleanup

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 18 matching lines @@
  */
 
 #ifndef CallbackPromiseAdapter_h
 #define CallbackPromiseAdapter_h
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "public/platform/WebCallbacks.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/TypeTraits.h"
 #include <memory>
+#include <utility>
 
 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,
@@ skipping 36 matching lines @@
 //     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
-//  - std::unique_ptr - WebPassOwnPtr translation ([Web]PassType[Impl], adopt, pass),
-//  - trivial WebType holder (TrivialWebTypeHolder).
+// are utility templates that provide the trivial WebType holder.
 
 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));
 
-    template <typename T> static T& adopt(T& x) { return x; }
-    template <typename T> static std::unique_ptr<T> adopt(std::unique_ptr<T>& x) { return std::move(x); }
-    template <typename T> static T pass(T& x) { return 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<typename S::WebType, typename T::WebType> {
     public:
         explicit Base(ScriptPromiseResolver* resolver) : m_resolver(resolver) {}
         ScriptPromiseResolver* resolver() { return m_resolver; }
 
     private:
         Persistent<ScriptPromiseResolver> m_resolver;
     };
 
     template <typename S, typename T>
     class OnSuccess : public Base<S, T> {
     public:
         explicit OnSuccess(ScriptPromiseResolver* resolver) : Base<S, T>(resolver) {}
-        void onSuccess(typename S::WebType r) override
+        void onSuccess(typename S::WebType result) override
         {
-            typename S::WebType result(adopt(r));
             ScriptPromiseResolver* resolver = this->resolver();
             if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
                 return;
-            resolver->resolve(S::take(resolver, pass(result)));
+            resolver->resolve(S::take(resolver, std::move(result)));
         }
     };
     template <typename T>
     class OnSuccess<CallbackPromiseAdapterTrivialWebTypeHolder<void>, T> : public Base<CallbackPromiseAdapterTrivialWebTypeHolder<void>, T> {
     public:
         explicit OnSuccess(ScriptPromiseResolver* resolver) : Base<CallbackPromiseAdapterTrivialWebTypeHolder<void>, T>(resolver) {}
         void onSuccess() override
         {
             ScriptPromiseResolver* resolver = this->resolver();
             if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
                 return;
             resolver->resolve();
         }
     };
     template <typename S, typename T>
     class OnError : public OnSuccess<S, T> {
     public:
         explicit OnError(ScriptPromiseResolver* resolver) : OnSuccess<S, T>(resolver) {}
         void onError(typename T::WebType e) override
         {
-            typename T::WebType result(adopt(e));
             ScriptPromiseResolver* resolver = this->resolver();
             if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
                 return;
             ScriptState::Scope scope(resolver->getScriptState());
-            resolver->reject(T::take(resolver, pass(result)));
+            resolver->reject(T::take(resolver, std::move(e)));
         }
     };
     template <typename S>
     class OnError<S, CallbackPromiseAdapterTrivialWebTypeHolder<void>> : public OnSuccess<S, CallbackPromiseAdapterTrivialWebTypeHolder<void>> {
     public:
         explicit OnError(ScriptPromiseResolver* resolver) : OnSuccess<S, CallbackPromiseAdapterTrivialWebTypeHolder<void>>(resolver) {}
         void onError() override
         {
             ScriptPromiseResolver* resolver = this->resolver();
             if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
@@ skipping 12 matching lines @@
 };
 
 } // namespace internal
 
 template <typename S, typename T>
 using CallbackPromiseAdapter = internal::CallbackPromiseAdapterInternal::CallbackPromiseAdapter<S, T>;
 
 } // namespace blink
 
 #endif