Created a MessageLoopProxy interface. This provides a thread-safe refcounted ...

chrome/browser/chrome_thread.h

 // Copyright (c) 2009 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 CHROME_BROWSER_CHROME_THREAD_H_
 #define CHROME_BROWSER_CHROME_THREAD_H_
 
 #include "base/lock.h"
 #include "base/task.h"
 #include "base/thread.h"
 
+class MessageLoopProxy;
+
 ///////////////////////////////////////////////////////////////////////////////
 // ChromeThread
 //
 // This class represents a thread that is known by a browser-wide name.  For
 // example, there is one IO thread for the entire browser process, and various
 // pieces of code find it useful to retrieve a pointer to the IO thread's
 // Invoke a task by thread ID:
 //
 //   ChromeThread::PostTask(ChromeThread::IO, FROM_HERE, task);
 //
@@ skipping 97 matching lines @@
   static bool IsWellKnownThread(ID identifier);
 
   // Callable on any thread.  Returns whether you're currently on a particular
   // thread.
   static bool CurrentlyOn(ID identifier);
 
   // If the current message loop is one of the known threads, returns true and
   // sets identifier to its ID.  Otherwise returns false.
   static bool GetCurrentThreadIdentifier(ID* identifier);
 
+  // Callers can hold on to a refcounted MessageLoopProxy beyond the lifetime
+  // of the thread.
+  static scoped_refptr<MessageLoopProxy> GetMessageLoopProxyForThread(
+      ID identifier);
+
   // 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).
   template<ID thread>
   struct DeleteOnThread {
     template<typename T>
@@ skipping 43 matching lines @@
   static Lock lock_;
 
   // An array of the ChromeThread objects.  This array is protected by |lock_|.
   // The threads are not owned by this array.  Typically, the threads are owned
   // on the UI thread by the g_browser_process object.  ChromeThreads remove
   // themselves from this array upon destruction.
   static ChromeThread* chrome_threads_[ID_COUNT];
 };
 
 #endif  // CHROME_BROWSER_CHROME_THREAD_H_