Support scoped_ptr in BrowserThread::DeleteOnThread.

content/public/browser/browser_thread.h

 // Copyright (c) 2012 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 CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
 #define CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 211 matching lines @@
   // Sets the delegate for the specified BrowserThread.
   //
   // Only one delegate may be registered at a time.  Delegates may be
   // unregistered by providing a NULL pointer.
   //
   // If the caller unregisters a delegate before CleanUp has been
   // called, it must perform its own locking to ensure the delegate is
   // not deleted while unregistering.
   static void SetDelegate(ID identifier, BrowserThreadDelegate* delegate);
 
-  // Use these templates in conjuction with RefCountedThreadSafe when you want
-  // to ensure that an object is deleted on a specific thread.  This is needed
-  // when an object can hop between threads (i.e. IO -> FILE -> IO), and thread
-  // switching delays can mean that the final IO tasks executes before the FILE
-  // task's stack unwinds.  This would lead to the object destructing on the
-  // FILE thread, which often is not what you want (i.e. to unregister from
-  // NotificationService, to notify other objects on the creating thread etc).
+  // Use these templates in conjunction with RefCountedThreadSafe or scoped_ptr
+  // when you want to ensure that an object is deleted on a specific thread.
+  // This is needed when an object can hop between threads
+  // (i.e. IO -> FILE -> IO), and thread switching delays can mean that the
+  // final IO tasks executes before the FILE task's stack unwinds.
+  // This would lead to the object destructing on the FILE thread, which often
+  // is not what you want (i.e. to unregister from NotificationService, to
+  // notify other objects on the creating thread etc).
   template<ID thread>
   struct DeleteOnThread {
     template<typename T>
     static void Destruct(const T* x) {
       if (CurrentlyOn(thread)) {
         delete x;
       } else {
         if (!DeleteSoon(thread, FROM_HERE, x)) {
 #if defined(UNIT_TEST)
           // Only logged under unit testing because leaks at shutdown
           // are acceptable under normal circumstances.
           LOG(ERROR) << "DeleteSoon failed on thread " << thread;
 #endif  // UNIT_TEST
         }
       }
     }
+    template <typename T>
+    inline void operator()(T* ptr) const {
+      enum { type_must_be_complete = sizeof(T) };
+      Destruct(ptr);
+    }
   };
 
-  // Sample usage:
+  // Sample usage with RefCountedThreadSafe:
   // class Foo
   //     : public base::RefCountedThreadSafe<
   //           Foo, BrowserThread::DeleteOnIOThread> {
   //
   // ...
   //  private:
   //   friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
   //   friend class base::DeleteHelper<Foo>;
   //
   //   ~Foo();
+  //
+  // Sample usage with scoped_ptr:
+  // scoped_ptr<Foo, BrowserThread::DeleteOnIOThread> ptr;
   struct DeleteOnUIThread : public DeleteOnThread<UI> { };
   struct DeleteOnIOThread : public DeleteOnThread<IO> { };
   struct DeleteOnFileThread : public DeleteOnThread<FILE> { };
   struct DeleteOnDBThread : public DeleteOnThread<DB> { };
 
   // Returns an appropriate error message for when DCHECK_CURRENTLY_ON() fails.
   static std::string GetDCheckCurrentlyOnErrorMessage(ID expected);
 
  private:
   friend class BrowserThreadImpl;
 
   BrowserThread() {}
   DISALLOW_COPY_AND_ASSIGN(BrowserThread);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_