Bug 1221371 - Remove unused Chromium callback code (r=jld)
☠☠ backed out by f620224aae8f ☠ ☠
authorBill McCloskey <billm@mozilla.com>
Mon, 02 Nov 2015 19:17:54 -0800
changeset 271653 a50c676caf7f12198f892e01ca1fb74fe0753df6
parent 271652 bd99e5060e1e3ecf627a7d5419dda8620c6b5fa6
child 271654 ea676347db72e895dcbba24408bf9a0bd955e123
push id67727
push userwmccloskey@mozilla.com
push dateSun, 08 Nov 2015 18:25:31 +0000
treeherdermozilla-inbound@a50c676caf7f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjld
bugs1221371
milestone45.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1221371 - Remove unused Chromium callback code (r=jld)
ipc/chromium/src/base/task.h
--- a/ipc/chromium/src/base/task.h
+++ b/ipc/chromium/src/base/task.h
@@ -360,208 +360,9 @@ class RunnableFunction : public Cancelab
 
 template <class Function, typename... Args>
 inline CancelableTask* NewRunnableFunction(Function function, Args&&... args) {
   typedef mozilla::Tuple<typename mozilla::Decay<Args>::Type...> ArgsTuple;
   return new RunnableFunction<Function, ArgsTuple>(
       function, mozilla::MakeTuple(mozilla::Forward<Args>(args)...));
 }
 
-// Callback --------------------------------------------------------------------
-//
-// A Callback is like a Task but with unbound parameters. It is basically an
-// object-oriented function pointer.
-//
-// Callbacks are designed to work with Tuples.  A set of helper functions and
-// classes is provided to hide the Tuple details from the consumer.  Client
-// code will generally work with the CallbackRunner base class, which merely
-// provides a Run method and is returned by the New* functions. This allows
-// users to not care which type of class implements the callback, only that it
-// has a certain number and type of arguments.
-//
-// The implementation of this is done by CallbackImpl, which inherits
-// CallbackStorage to store the data. This allows the storage of the data
-// (requiring the class type T) to be hidden from users, who will want to call
-// this regardless of the implementor's type T.
-//
-// Note that callbacks currently have no facility for cancelling or abandoning
-// them. We currently handle this at a higher level for cases where this is
-// necessary. The pointer in a callback must remain valid until the callback
-// is made.
-//
-// Like Task, the callback executor is responsible for deleting the callback
-// pointer once the callback has executed.
-//
-// Example client usage:
-//   void Object::DoStuff(int, string);
-//   Callback2<int, string>::Type* callback =
-//       NewCallback(obj, &Object::DoStuff);
-//   callback->Run(5, string("hello"));
-//   delete callback;
-// or, equivalently, using tuples directly:
-//   CallbackRunner<Tuple2<int, string> >* callback =
-//       NewCallback(obj, &Object::DoStuff);
-//   callback->RunWithParams(base::MakeTuple(5, string("hello")));
-
-// Base for all Callbacks that handles storage of the pointers.
-template <class T, typename Method>
-class CallbackStorage {
- public:
-  CallbackStorage(T* obj, Method meth) : obj_(obj), meth_(meth) {
-  }
-
- protected:
-  T* MOZ_UNSAFE_REF("The validity of this pointer must be enforced by "
-                    "external factors.") obj_;
-  Method meth_;
-};
-
-// Interface that is exposed to the consumer, that does the actual calling
-// of the method.
-template <typename Params>
-class CallbackRunner {
- public:
-  typedef Params TupleType;
-
-  virtual ~CallbackRunner() {}
-  virtual void RunWithParams(const Params& params) = 0;
-
-  // Convenience functions so callers don't have to deal with Tuples.
-  inline void Run() {
-    RunWithParams(Tuple0());
-  }
-
-  template <typename Arg1>
-  inline void Run(const Arg1& a) {
-    RunWithParams(Params(a));
-  }
-
-  template <typename Arg1, typename Arg2>
-  inline void Run(const Arg1& a, const Arg2& b) {
-    RunWithParams(Params(a, b));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3>
-  inline void Run(const Arg1& a, const Arg2& b, const Arg3& c) {
-    RunWithParams(Params(a, b, c));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-  inline void Run(const Arg1& a, const Arg2& b, const Arg3& c, const Arg4& d) {
-    RunWithParams(Params(a, b, c, d));
-  }
-
-  template <typename Arg1, typename Arg2, typename Arg3,
-            typename Arg4, typename Arg5>
-  inline void Run(const Arg1& a, const Arg2& b, const Arg3& c,
-                  const Arg4& d, const Arg5& e) {
-    RunWithParams(Params(a, b, c, d, e));
-  }
-};
-
-template <class T, typename Method, typename Params>
-class CallbackImpl : public CallbackStorage<T, Method>,
-                     public CallbackRunner<Params> {
- public:
-  CallbackImpl(T* obj, Method meth) : CallbackStorage<T, Method>(obj, meth) {
-  }
-  virtual void RunWithParams(const Params& params) {
-    // use "this->" to force C++ to look inside our templatized base class; see
-    // Effective C++, 3rd Ed, item 43, p210 for details.
-    DispatchToMethod(this->obj_, this->meth_, params);
-  }
-};
-
-// 0-arg implementation
-struct Callback0 {
-  typedef CallbackRunner<Tuple0> Type;
-};
-
-template <class T>
-typename Callback0::Type* NewCallback(T* object, void (T::*method)()) {
-  return new CallbackImpl<T, void (T::*)(), Tuple0 >(object, method);
-}
-
-// 1-arg implementation
-template <typename Arg1>
-struct Callback1 {
-  typedef CallbackRunner<Tuple1<Arg1> > Type;
-};
-
-template <class T, typename Arg1>
-typename Callback1<Arg1>::Type* NewCallback(T* object,
-                                            void (T::*method)(Arg1)) {
-  return new CallbackImpl<T, void (T::*)(Arg1), Tuple1<Arg1> >(object, method);
-}
-
-// 2-arg implementation
-template <typename Arg1, typename Arg2>
-struct Callback2 {
-  typedef CallbackRunner<Tuple2<Arg1, Arg2> > Type;
-};
-
-template <class T, typename Arg1, typename Arg2>
-typename Callback2<Arg1, Arg2>::Type* NewCallback(
-    T* object,
-    void (T::*method)(Arg1, Arg2)) {
-  return new CallbackImpl<T, void (T::*)(Arg1, Arg2),
-      Tuple2<Arg1, Arg2> >(object, method);
-}
-
-// 3-arg implementation
-template <typename Arg1, typename Arg2, typename Arg3>
-struct Callback3 {
-  typedef CallbackRunner<Tuple3<Arg1, Arg2, Arg3> > Type;
-};
-
-template <class T, typename Arg1, typename Arg2, typename Arg3>
-typename Callback3<Arg1, Arg2, Arg3>::Type* NewCallback(
-    T* object,
-    void (T::*method)(Arg1, Arg2, Arg3)) {
-  return new CallbackImpl<T,  void (T::*)(Arg1, Arg2, Arg3),
-      Tuple3<Arg1, Arg2, Arg3> >(object, method);
-}
-
-// 4-arg implementation
-template <typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-struct Callback4 {
-  typedef CallbackRunner<Tuple4<Arg1, Arg2, Arg3, Arg4> > Type;
-};
-
-template <class T, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
-typename Callback4<Arg1, Arg2, Arg3, Arg4>::Type* NewCallback(
-    T* object,
-    void (T::*method)(Arg1, Arg2, Arg3, Arg4)) {
-  return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4),
-      Tuple4<Arg1, Arg2, Arg3, Arg4> >(object, method);
-}
-
-// 5-arg implementation
-template <typename Arg1, typename Arg2, typename Arg3,
-          typename Arg4, typename Arg5>
-struct Callback5 {
-  typedef CallbackRunner<Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> > Type;
-};
-
-template <class T, typename Arg1, typename Arg2,
-          typename Arg3, typename Arg4, typename Arg5>
-typename Callback5<Arg1, Arg2, Arg3, Arg4, Arg5>::Type* NewCallback(
-    T* object,
-    void (T::*method)(Arg1, Arg2, Arg3, Arg4, Arg5)) {
-  return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4, Arg5),
-      Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> >(object, method);
-}
-
-// An UnboundMethod is a wrapper for a method where the actual object is
-// provided at Run dispatch time.
-template <class T, class Method, class Params>
-class UnboundMethod {
- public:
-  UnboundMethod(Method m, Params p) : m_(m), p_(p) {}
-  void Run(T* obj) const {
-    DispatchToMethod(obj, m_, p_);
-  }
- private:
-  Method m_;
-  Params p_;
-};
-
 #endif  // BASE_TASK_H_