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

base/bind_helpers.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.
 
 // This defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
 // It also defines a set of simple functions and utilities that people want
 // when using Callback<> and Bind().
@@ skipping 161 matching lines @@
 namespace base {
 
 template <typename T>
 struct IsWeakReceiver;
 
 template <typename>
 struct BindUnwrapTraits;
 
 namespace internal {
 
+template <typename Functor, typename SFINAE = void>
+struct FunctorTraits;
+
 template <typename T>
 class UnretainedWrapper {
  public:
   explicit UnretainedWrapper(T* o) : ptr_(o) {}
   T* get() const { return ptr_; }
  private:
   T* ptr_;
 };
 
 template <typename T>
@@ skipping 322 matching lines @@
   }
 };
 
 template <typename T>
 struct BindUnwrapTraits<internal::PassedWrapper<T>> {
   static T Unwrap(const internal::PassedWrapper<T>& o) {
     return o.Take();
   }
 };
 
+// An injection point to support Callback::IsCancelled in a specific form of
+// base::Bind.
+// Specialize BindCancellationChecker to support Callback::IsCancelled, set
+// is_cancellable to true in the specialization, and implement Run() method.
+// BindCancellationChecker<>::Run() should return true if the resulting callback
+// is cancelled.
+template <typename Functor, typename BoundArgsTuple, typename SFINAE = void>
+struct BindCancellationChecker {

[dcheng, 2016/11/10 06:29:23]

My main thoughts are around naming.

Most of our injection points for Bind / Callback are named
SomethingSomethingTraits. For consistency in naming, it might be nice to keep a
similar theme here. Maybe CallbackCancellationTraits? Since it's a Callback
(which is the result of a Bind) that is cancellable.

[tzik, 2016/11/10 07:21:14]

Done.

+  static constexpr bool is_cancellable = false;
+};
+
+// Specialization for method bound to weak pointer receiver.
+template <typename Functor, typename... BoundArgs>
+struct BindCancellationChecker<Functor,
+                               std::tuple<BoundArgs...>,
+                               typename std::enable_if<internal::IsWeakMethod<
+                                   internal::FunctorTraits<Functor>::is_method,
+                                   BoundArgs...>::value>::type> {
+  static constexpr bool is_cancellable = true;
+
+  template <typename Receiver, typename... Args>
+  static bool Run(const Functor&, const Receiver& receiver, const Args&...) {

[dcheng, 2016/11/10 06:29:23]

Similarly, I think calling this Run() is a bit confusing (since it overlaps with
Callback::Run). Would it be OK to just call this IsCancelled()?

[tzik, 2016/11/10 07:21:14]

Done.

+    return !receiver;
+  }
+};
+
+// Specialization for a nested bind.
+template <typename Signature,
+          typename... BoundArgs,
+          internal::CopyMode copy_mode,
+          internal::RepeatMode repeat_mode>
+struct BindCancellationChecker<Callback<Signature, copy_mode, repeat_mode>,
+                               std::tuple<BoundArgs...>> {
+  static constexpr bool is_cancellable = true;
+
+  template <typename Functor>
+  static bool Run(const Functor& functor, const BoundArgs&...) {
+    return functor.IsCancelled();
+  }
+};
+
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_