Remove unneeded type indirections from CallbackPromiseAdapter.

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 98 matching lines @@
 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<std::unique_ptr<T>> {
-        using Type = std::unique_ptr<T>;
-    };
-    template <typename T>
-    struct WebPassTypeImpl {
-        using Type = T;
-    };
-    template <typename 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 std::unique_ptr<T> adopt(std::unique_ptr<T>& x) { return std::move(x); }
-    template <typename T> static PassType<T> pass(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<WebPassType<typename S::WebType>, WebPassType<typename T::WebType>> {
+    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(WebPassType<typename S::WebType> r) override
+        void onSuccess(typename S::WebType r) 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)));
         }
     };
     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(WebPassType<typename T::WebType> e) override
+        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)));
         }
     };
     template <typename S>
@@ skipping 19 matching lines @@
 };
 
 } // namespace internal
 
 template <typename S, typename T>
 using CallbackPromiseAdapter = internal::CallbackPromiseAdapterInternal::CallbackPromiseAdapter<S, T>;
 
 } // namespace blink
 
 #endif