Assert that thread-safe reference counting is used with...

base/task.h

 // Copyright (c) 2006-2008 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_TASK_H_
 #define BASE_TASK_H_
 
 #include "base/non_thread_safe.h"
 #include "base/tracked.h"
 #include "base/tuple.h"
@@ skipping 187 matching lines @@
 //
 // 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.
 
 template <class T>
 struct RunnableMethodTraits {
-  static void RetainCallee(T* obj) {
+  RunnableMethodTraits() {
+#ifndef NDEBUG
+    origin_thread_id_ = 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_ != PlatformThread::CurrentId())
+      DCHECK(T::ImplementsThreadSafeReferenceCounting());
+#endif
+  }
+
+  void RetainCallee(T* obj) {
     obj->AddRef();
   }
-  static void ReleaseCallee(T* obj) {
+
+  void ReleaseCallee(T* obj) {
     obj->Release();
   }
+
+ private:
+#ifndef NDEBUG
+  PlatformThreadId origin_thread_id_;
+#endif
 };
 
 // RunnableMethod and RunnableFunction -----------------------------------------
 //
 // 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 and
 // NewRunnableFunction 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 mathod
 //
 // 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]])
 // PostTask(FROM_HERE, NewRunnableFunction(&function[, a[, b]])
 
 // RunnableMethod and NewRunnableMethod implementation -------------------------
 
 template <class T, class Method, class Params>
-class RunnableMethod : public CancelableTask,
-                       public RunnableMethodTraits<T> {
+class RunnableMethod : public CancelableTask {
  public:
   RunnableMethod(T* obj, Method meth, const Params& params)
       : obj_(obj), meth_(meth), params_(params) {
-    RetainCallee(obj_);
+    traits_.RetainCallee(obj_);
   }
+
   ~RunnableMethod() {
     ReleaseCallee();
   }
 
   virtual void Run() {
     if (obj_)
       DispatchToMethod(obj_, meth_, params_);
   }
 
   virtual void Cancel() {
     ReleaseCallee();
   }
 
  private:
   void ReleaseCallee() {
     if (obj_) {
-      RunnableMethodTraits<T>::ReleaseCallee(obj_);
+      traits_.ReleaseCallee(obj_);
       obj_ = NULL;
     }
   }
 
   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,
@@ skipping 362 matching lines @@
 
 template <class T, typename ReturnValue>
 typename CallbackWithReturnValue<ReturnValue>::Type*
 NewCallbackWithReturnValue(T* object, ReturnValue (T::*method)()) {
   return new CallbackWithReturnValueImpl<T, ReturnValue (T::*)(), ReturnValue>(
       object, method);
 }
 
 
 #endif  // BASE_TASK_H_