Support external task cancellation mechanisms in base::Callback::IsCancelled

base/bind_internal.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_INTERNAL_H_
 #define BASE_BIND_INTERNAL_H_
 
 #include <stddef.h>
 
 #include <tuple>
@@ skipping 112 matching lines @@
 struct ForceVoidReturn;
 
 template <typename R, typename... Args>
 struct ForceVoidReturn<R(Args...)> {
   using RunType = void(Args...);
 };
 
 // FunctorTraits<>
 //
 // See description at top of file.
-template <typename Functor, typename SFINAE = void>
+template <typename Functor, typename SFINAE>
 struct FunctorTraits;
 
 // For a callable type that is convertible to the corresponding function type.
 // This specialization is intended to allow binding captureless lambdas by
 // base::Bind(), based on the fact that captureless lambdas can be convertible
 // to the function type while capturing lambdas can't.
 template <typename Functor>
 struct FunctorTraits<
     Functor,
     typename std::enable_if<IsConvertibleToRunType<Functor>::value>::type> {
@@ skipping 236 matching lines @@
 IsNull(const Functor& functor) {
   return !functor;
 }
 
 template <typename Functor>
 typename std::enable_if<!FunctorTraits<Functor>::is_nullable, bool>::type
 IsNull(const Functor&) {
   return false;
 }
 
-template <typename Functor, typename... BoundArgs>
-struct BindState;
+// Used by ApplyCancellationChecker below.
+template <typename Functor, typename BoundArgsTuple, size_t... indices>
+bool ApplyCancellationCheckerImpl(const Functor& functor,
+                                  const BoundArgsTuple& bound_args,
+                                  IndexSequence<indices...>) {
+  return BindCancellationChecker<Functor, BoundArgsTuple>::Run(
+      functor, base::get<indices>(bound_args)...);
+}
 
-template <typename BindStateType, typename SFINAE = void>
-struct CancellationChecker {
-  static constexpr bool is_cancellable = false;
-  static bool Run(const BindStateBase*) {
-    return false;
-  }
-};
-
-template <typename Functor, typename... BoundArgs>
-struct CancellationChecker<
-    BindState<Functor, BoundArgs...>,
-    typename std::enable_if<IsWeakMethod<FunctorTraits<Functor>::is_method,
-                                         BoundArgs...>::value>::type> {
-  static constexpr bool is_cancellable = true;
-  static bool Run(const BindStateBase* base) {
-    using BindStateType = BindState<Functor, BoundArgs...>;
-    const BindStateType* bind_state = static_cast<const BindStateType*>(base);
-    return !base::get<0>(bind_state->bound_args_);
-  }
-};
-
-template <typename Signature,
-          typename... BoundArgs,
-          CopyMode copy_mode,
-          RepeatMode repeat_mode>
-struct CancellationChecker<
-    BindState<Callback<Signature, copy_mode, repeat_mode>, BoundArgs...>> {
-  static constexpr bool is_cancellable = true;
-  static bool Run(const BindStateBase* base) {
-    using Functor = Callback<Signature, copy_mode, repeat_mode>;
-    using BindStateType = BindState<Functor, BoundArgs...>;
-    const BindStateType* bind_state = static_cast<const BindStateType*>(base);
-    return bind_state->functor_.IsCancelled();
-  }
+// Relays |base| to corresponding BindCancellationChecker<>::Run(). Returns true
+// if the callback |base| represents is canceled.
+template <typename BindStateType>
+bool ApplyCancellationChecker(const BindStateBase* base) {
+  const BindStateType* storage = static_cast<const BindStateType*>(base);
+  static constexpr size_t num_bound_args =
+      std::tuple_size<decltype(storage->bound_args_)>::value;
+  return ApplyCancellationCheckerImpl(storage->functor_, storage->bound_args_,
+                                      MakeIndexSequence<num_bound_args>());
 };
 
 // Template helpers to detect using Bind() on a base::Callback without any
 // additional arguments. In that case, the original base::Callback object should
 // just be directly used.
 template <typename Functor, typename... BoundArgs>
 struct BindingCallbackWithNoArgs {
   static constexpr bool value = false;
 };
 
 template <typename Signature,
           typename... BoundArgs,
           CopyMode copy_mode,
           RepeatMode repeat_mode>
 struct BindingCallbackWithNoArgs<Callback<Signature, copy_mode, repeat_mode>,
                                  BoundArgs...> {
   static constexpr bool value = sizeof...(BoundArgs) == 0;
 };
 
 // BindState<>
 //
 // This stores all the state passed into Bind().
 template <typename Functor, typename... BoundArgs>
 struct BindState final : BindStateBase {
   using IsCancellable = std::integral_constant<
-      bool, CancellationChecker<BindState>::is_cancellable>;
+      bool,
+      BindCancellationChecker<Functor,
+                              std::tuple<BoundArgs...>>::is_cancellable>;
 
   template <typename ForwardFunctor, typename... ForwardBoundArgs>
   explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
                      ForwardFunctor&& functor,
                      ForwardBoundArgs&&... bound_args)
-      // IsCancellable is std::false_type if the CancellationChecker<>::Run
+      // IsCancellable is std::false_type if the BindCancellationChecker<>::Run
       // returns always false. Otherwise, it's std::true_type.
       : BindState(IsCancellable{},
                   invoke_func,
                   std::forward<ForwardFunctor>(functor),
                   std::forward<ForwardBoundArgs>(bound_args)...) {
     static_assert(!BindingCallbackWithNoArgs<Functor, BoundArgs...>::value,
                   "Attempting to bind a base::Callback with no additional "
                   "arguments: save a heap allocation and use the original "
                   "base::Callback object");
   }
 
   Functor functor_;
   std::tuple<BoundArgs...> bound_args_;
 
  private:
   template <typename ForwardFunctor, typename... ForwardBoundArgs>
   explicit BindState(std::true_type,
                      BindStateBase::InvokeFuncStorage invoke_func,
                      ForwardFunctor&& functor,
                      ForwardBoundArgs&&... bound_args)
-      : BindStateBase(invoke_func, &Destroy,
-                      &CancellationChecker<BindState>::Run),
+      : BindStateBase(invoke_func,
+                      &Destroy,
+                      &ApplyCancellationChecker<BindState>),
         functor_(std::forward<ForwardFunctor>(functor)),
         bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
     DCHECK(!IsNull(functor_));
   }
 
   template <typename ForwardFunctor, typename... ForwardBoundArgs>
   explicit BindState(std::false_type,
                      BindStateBase::InvokeFuncStorage invoke_func,
                      ForwardFunctor&& functor,
                      ForwardBoundArgs&&... bound_args)
@@ skipping 58 matching lines @@
 
 // Returns a RunType of bound functor.
 // E.g. MakeUnboundRunType<R(A, B, C), A, B> is evaluated to R(C).
 template <typename Functor, typename... BoundArgs>
 using MakeUnboundRunType =
     typename internal::MakeUnboundRunTypeImpl<Functor, BoundArgs...>::Type;
 
 }  // namespace base
 
 #endif  // BASE_BIND_INTERNAL_H_