Revert 111695 - 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/synchronization/lock.h"
 #include "base/task.h"
-#include "base/tracked_objects.h"
+#include "base/threading/thread.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/threading/thread.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 {
+class CONTENT_EXPORT BrowserThread : public base::Thread {
  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.
-  //
-  // 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).
   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:
-  friend class BrowserThreadImpl;
+  // Construct a BrowserThread with the supplied identifier.  It is an error
+  // to construct a BrowserThread that already exists.
+  explicit BrowserThread(ID identifier);
 
-  BrowserThread() {}
-  DISALLOW_COPY_AND_ASSIGN(BrowserThread);
+  // 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();
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_