Decouple Invoker from BindState

base/bind.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_BIND_H_
 #define BASE_BIND_H_
 
 #include "base/bind_internal.h"
 
 // -----------------------------------------------------------------------------
@@ skipping 28 matching lines @@
 // via an indirection like we do below.
 //
 // TODO(ajwong): We might be able to avoid this now, but need to test.
 //
 // It is possible to move most of the static_assert into BindState<>, but it
 // feels a little nicer to have the asserts here so people do not need to crack
 // open bind_internal.h.  On the other hand, it makes Bind() harder to read.
 
 namespace base {
 
-namespace internal {
-
-// Don't use Alias Template directly here to avoid a compile error on MSVC2013.
 template <typename Functor, typename... Args>
-struct MakeUnboundRunTypeImpl {
-  using Type =
-      typename BindState<
-          typename FunctorTraits<Functor>::RunnableType,
-          typename FunctorTraits<Functor>::RunType,
-          Args...>::UnboundRunType;
-};
-
-}  // namespace internal
+using MakeUnboundRunType = internal::MakeUnboundRunType<Functor, Args...>;

[dcheng, 2016/06/27 07:57:22]

Nit: It seems a little unusual to have base::MakeUnboundRunTYpe and
base::internal::MakeUnboundRunType. I wonder if we can just qualify references
with internal:: as needed?

[tzik, 2016/06/27 08:43:11]

We have several place that uses MakeUnboundRunType outside of //base:
wtf/Functional.h and gmock_mutant.h.
How about unifying them to base::MakeUnboundRunType rather than base::internal::
one?

 
 template <typename Functor, typename... Args>
-using MakeUnboundRunType =
-    typename internal::MakeUnboundRunTypeImpl<Functor, Args...>::Type;
-
-template <typename Functor, typename... Args>
-base::Callback<MakeUnboundRunType<Functor, Args...>>
+inline base::Callback<MakeUnboundRunType<Functor, Args...>>
 Bind(Functor functor, Args&&... args) {
   // Type aliases for how to store and run the functor.
   using RunnableType = typename internal::FunctorTraits<Functor>::RunnableType;
-  using RunType = typename internal::FunctorTraits<Functor>::RunType;
 
   // Use RunnableType::RunType instead of RunType above because our
   // checks below for bound references need to know what the actual
   // functor is going to interpret the argument as.
   using BoundRunType = typename RunnableType::RunType;
 
   using BoundArgs =
       internal::TakeTypeListItem<sizeof...(Args),
                                  internal::ExtractArgs<BoundRunType>>;
 
@@ skipping 10 matching lines @@
   // For methods, we need to be careful for parameter 1.  We do not require
   // a scoped_refptr because BindState<> itself takes care of AddRef() for
   // methods. We also disallow binding of an array as the method's target
   // object.
   static_assert(!internal::BindsArrayToFirstArg<is_method, Args...>::value,
                 "first bound argument to method cannot be array");
   static_assert(
       !internal::HasRefCountedParamAsRawPtr<is_method, Args...>::value,
       "a parameter is a refcounted type and needs scoped_refptr");
 
-  using BindState = internal::BindState<RunnableType, RunType, Args...>;
+  using BindState = internal::BindState<RunnableType, Args...>;
+  using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
+  using CallbackType = Callback<UnboundRunType>;
+  using Invoker = internal::Invoker<BindState, UnboundRunType>;
 
-  return Callback<typename BindState::UnboundRunType>(
-      new BindState(internal::MakeRunnable(functor),
-                    std::forward<Args>(args)...));
+  return CallbackType(new BindState(internal::MakeRunnable(functor),
+                                    std::forward<Args>(args)...),
+                      &Invoker::Run);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_H_