Have content/ create and destroy its own threads.

content/public/browser/browser_thread.h

 // Copyright (c) 2011 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_
 #pragma once
 
+#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/task.h"
+#include "base/tracked_objects.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/browser_thread_delegate.h"
+
+// TODO(joi): Remove these in a follow-up change and IWYU in files
+// that were getting them directly or indirectly from here.
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
-#include "base/task.h"
 #include "base/threading/thread.h"
-#include "content/common/content_export.h"
 
 #if defined(UNIT_TEST)
 #include "base/logging.h"
 #endif  // UNIT_TEST
 
 namespace base {
 class MessageLoopProxy;
+class Thread;
 }
 
 namespace content {
 
 class BrowserThreadImpl;
-class DeprecatedBrowserThread;
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserThread
 //
 // Utility functions for threads that are 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 message loop.
 //
 // Invoke a task by thread ID:
 //
 //   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, task);
 //
 // The return value is false if the task couldn't be posted because the target
 // thread doesn't exist.  If this could lead to data loss, you need to check the
 // result and restructure the code to ensure it doesn't occur.
 //
 // This class automatically handles the lifetime of different threads.
 // It's always safe to call PostTask on any thread.  If it's not yet created,
 // the task is deleted.  There are no race conditions.  If the thread that the
 // task is posted to is guaranteed to outlive the current thread, then no locks
 // are used.  You should never need to cache pointers to MessageLoops, since
 // they're not thread safe.
-class CONTENT_EXPORT BrowserThread : public base::Thread {
+class CONTENT_EXPORT BrowserThread {
  public:
   // An enumeration of the well-known threads.
   // NOTE: threads must be listed in the order of their life-time, with each
   // thread outliving every other thread below it.
   enum ID {
     // The main thread in the browser.
     UI,
 
     // This is the thread that interacts with the database.
     DB,
@@ skipping 102 matching lines @@
 
   // 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<base::MessageLoopProxy> GetMessageLoopProxyForThread(
       ID identifier);
 
+  // Gets the Thread object for the specified thread, or NULL if the
+  // thread has not been created (or has been destroyed during
+  // shutdown).
+  //
+  // Before calling this, you must have called content::ContentMain
+  // with a command-line that would specify a browser process (e.g. an
+  // empty command line).
+  //
+  // This is unsafe as your pointer may become invalid close to
+  // shutdown.
+  //
+  // TODO(joi): Remove this once clients such as BrowserProcessImpl
+  // (and classes that call things like
+  // g_browser_process->file_thread()) are switched to using
+  // MessageLoopProxy.
+  static base::Thread* UnsafeGetBrowserThread(ID identifier);
+
+  // Sets the delegate for the specified BrowserThread.
+  //
+  // This may be called only once per BrowserThread::ID, and must be
+  // called with a non-NULL delegate.
+  //
+  // The caller must guaranteed that the delegate lives until CleanUp
+  // has been called on it.  It is however OK to not set a delegate
+  // until after BrowserThread initialization, in which case the
+  // delegate never receives the Init method call.
+  //
+  // Note that delegates that are set after a thread has terminated
+  // will never receive a CleanUp call, meaning delegates that delete
+  // themselves after CleanUp will leak if set after the thread has
+  // terminated.
+  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).
   template<ID thread>
   struct DeleteOnThread {
     template<typename T>
@@ skipping 23 matching lines @@
   //   friend class DeleteTask<Foo>;
   //
   //   ~Foo();
   struct DeleteOnUIThread : public DeleteOnThread<UI> { };
   struct DeleteOnIOThread : public DeleteOnThread<IO> { };
   struct DeleteOnFileThread : public DeleteOnThread<FILE> { };
   struct DeleteOnDBThread : public DeleteOnThread<DB> { };
   struct DeleteOnWebKitThread : public DeleteOnThread<WEBKIT> { };
 
  private:
-  // Construct a BrowserThread with the supplied identifier.  It is an error
-  // to construct a BrowserThread that already exists.
-  explicit BrowserThread(ID identifier);
+  friend class BrowserThreadImpl;
 
-  // Special constructor for the main (UI) thread and unittests. We use a dummy
-  // thread here since the main thread already exists.
-  BrowserThread(ID identifier, MessageLoop* message_loop);
-
-  virtual ~BrowserThread();
-
-  // Common initialization code for the constructors.
-  void Initialize();
-
-  // Constructors are only available through this subclass.
-  friend class content::BrowserThreadImpl;
-
-  // TODO(joi): Remove.
-  friend class DeprecatedBrowserThread;
-
-  // The identifier of this thread.  Only one thread can exist with a given
-  // identifier at a given time.
-  // TODO(joi): Move to BrowserThreadImpl, and make constructors here
-  // do-nothing.
-  ID identifier_;
-};
-
-// Temporary escape hatch for chrome/ to construct BrowserThread,
-// until we make content/ construct its own threads.
-class CONTENT_EXPORT DeprecatedBrowserThread : public BrowserThread {
- public:
-  explicit DeprecatedBrowserThread(BrowserThread::ID identifier);
-  DeprecatedBrowserThread(BrowserThread::ID identifier,
-                          MessageLoop* message_loop);
-  virtual ~DeprecatedBrowserThread();
+  BrowserThread() {}
+  DISALLOW_COPY_AND_ASSIGN(BrowserThread);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_