diff options
Diffstat (limited to 'base/task.h')
| -rw-r--r-- | base/task.h | 228 |
1 files changed, 3 insertions, 225 deletions
diff --git a/base/task.h b/base/task.h index 9666a65..f22300a 100644 --- a/base/task.h +++ b/base/task.h @@ -70,231 +70,9 @@ void DeletePointer(T* obj) { delete obj; } -// RunnableMethodTraits -------------------------------------------------------- -// -// This traits-class is used by RunnableMethod to manage the lifetime of the -// callee object. By default, it is assumed that the callee supports AddRef -// and Release methods. A particular class can specialize this template to -// define other lifetime management. For example, if the callee is known to -// live longer than the RunnableMethod object, then a RunnableMethodTraits -// struct could be defined with empty RetainCallee and ReleaseCallee methods. -// -// The DISABLE_RUNNABLE_METHOD_REFCOUNT macro is provided as a convenient way -// for declaring a RunnableMethodTraits that disables refcounting. - -template <class T> -struct RunnableMethodTraits { - RunnableMethodTraits() { -#ifndef NDEBUG - origin_thread_id_ = base::PlatformThread::CurrentId(); -#endif - } - - ~RunnableMethodTraits() { -#ifndef NDEBUG - // If destroyed on a separate thread, then we had better have been using - // thread-safe reference counting! - if (origin_thread_id_ != base::PlatformThread::CurrentId()) - DCHECK(T::ImplementsThreadSafeReferenceCounting()); -#endif - } - - void RetainCallee(T* obj) { -#ifndef NDEBUG - // Catch NewRunnableMethod being called in an object's constructor. This - // isn't safe since the method can be invoked before the constructor - // completes, causing the object to be deleted. - obj->AddRef(); - obj->Release(); -#endif - obj->AddRef(); - } - - void ReleaseCallee(T* obj) { - obj->Release(); - } - - private: -#ifndef NDEBUG - base::PlatformThreadId origin_thread_id_; -#endif -}; - -// Convenience macro for declaring a RunnableMethodTraits that disables -// refcounting of a class. This is useful if you know that the callee -// will outlive the RunnableMethod object and thus do not need the ref counts. -// -// The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the -// global namespace scope. Example: -// -// namespace foo { -// class Bar { -// ... -// }; -// } // namespace foo -// -// DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar); -// -// This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the -// class. -#define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \ - template <> \ - struct RunnableMethodTraits<TypeName> { \ - void RetainCallee(TypeName* manager) {} \ - void ReleaseCallee(TypeName* manager) {} \ - } - -// RunnableMethod -------------------------------------------------------------- -// -// Runnable methods are a type of task that call a function on an object when -// they are run. We implement both an object and a set of NewRunnableMethod -// functions for convenience. These functions are overloaded and will infer the -// template types, simplifying calling code. -// -// The template definitions all use the following names: -// T - the class type of the object you're supplying -// this is not needed for the Static version of the call -// Method/Function - the signature of a pointer to the method or function you -// want to call -// Param - the parameter(s) to the method, possibly packed as a Tuple -// A - the first parameter (if any) to the method -// B - the second parameter (if any) to the method -// -// Put these all together and you get an object that can call a method whose -// signature is: -// R T::MyFunction([A[, B]]) -// -// Usage: -// PostTask(FROM_HERE, NewRunnableMethod(object, &Object::method[, a[, b]]) - -// RunnableMethod and NewRunnableMethod implementation ------------------------- - -template <class T, class Method, class Params> -class RunnableMethod : public CancelableTask { - public: - RunnableMethod(T* obj, Method meth, const Params& params) - : obj_(obj), meth_(meth), params_(params) { - traits_.RetainCallee(obj_); - COMPILE_ASSERT( - (base::internal::ParamsUseScopedRefptrCorrectly<Params>::value), - badrunnablemethodparams); - } - - ~RunnableMethod() { - ReleaseCallee(); - obj_ = reinterpret_cast<T*>(base::kDeadTask); - } - - virtual void Run() { - if (obj_) - DispatchToMethod(obj_, meth_, params_); - } - - virtual void Cancel() { - ReleaseCallee(); - } - - private: - void ReleaseCallee() { - T* obj = obj_; - obj_ = NULL; - if (obj) - traits_.ReleaseCallee(obj); - } - - T* obj_; - Method meth_; - Params params_; - RunnableMethodTraits<T> traits_; -}; - -template <class T, class Method> -inline CancelableTask* NewRunnableMethod(T* object, Method method) { - return new RunnableMethod<T, Method, Tuple0>(object, method, MakeTuple()); -} - -template <class T, class Method, class A> -inline CancelableTask* NewRunnableMethod(T* object, Method method, const A& a) { - return new RunnableMethod<T, Method, Tuple1<A> >(object, - method, - MakeTuple(a)); -} - -template <class T, class Method, class A, class B> -inline CancelableTask* NewRunnableMethod(T* object, Method method, -const A& a, const B& b) { - return new RunnableMethod<T, Method, Tuple2<A, B> >(object, method, - MakeTuple(a, b)); -} - -template <class T, class Method, class A, class B, class C> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, const C& c) { - return new RunnableMethod<T, Method, Tuple3<A, B, C> >(object, method, - MakeTuple(a, b, c)); -} - -template <class T, class Method, class A, class B, class C, class D> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, - const C& c, const D& d) { - return new RunnableMethod<T, Method, Tuple4<A, B, C, D> >(object, method, - MakeTuple(a, b, - c, d)); -} - -template <class T, class Method, class A, class B, class C, class D, class E> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, - const C& c, const D& d, const E& e) { - return new RunnableMethod<T, - Method, - Tuple5<A, B, C, D, E> >(object, - method, - MakeTuple(a, b, c, d, e)); -} - -template <class T, class Method, class A, class B, class C, class D, class E, - class F> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, - const C& c, const D& d, const E& e, - const F& f) { - return new RunnableMethod<T, - Method, - Tuple6<A, B, C, D, E, F> >(object, - method, - MakeTuple(a, b, c, d, e, - f)); -} - -template <class T, class Method, class A, class B, class C, class D, class E, - class F, class G> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, - const C& c, const D& d, const E& e, - const F& f, const G& g) { - return new RunnableMethod<T, - Method, - Tuple7<A, B, C, D, E, F, G> >(object, - method, - MakeTuple(a, b, c, d, - e, f, g)); -} - -template <class T, class Method, class A, class B, class C, class D, class E, - class F, class G, class H> -inline CancelableTask* NewRunnableMethod(T* object, Method method, - const A& a, const B& b, - const C& c, const D& d, const E& e, - const F& f, const G& g, const H& h) { - return new RunnableMethod<T, - Method, - Tuple8<A, B, C, D, E, F, G, H> >(object, - method, - MakeTuple(a, b, c, - d, e, f, - g, h)); +template<typename T> +void ReleasePointer(T* obj) { + obj->Release(); } namespace base { |