Salient parts of http://codereview.chromium.org/8392042/

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_BROWSER_BROWSER_THREAD_H_
-#define CONTENT_BROWSER_BROWSER_THREAD_H_
+#ifndef CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
+#define CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_
 #pragma once
 
 #include "base/callback.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;
 }
 
+namespace content {
+class BrowserThreadImpl;
+}
+
+class DeprecatedBrowserThread;
+
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserThread
 //
-// 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
+// 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,
@@ skipping 35 matching lines @@
     // as hooks into websocket layer.
     WEB_SOCKET_PROXY,
 #endif
 
     // This identifier does not represent a thread.  Instead it counts the
     // number of well-known threads.  Insert new well-known threads before this
     // identifier.
     ID_COUNT
   };
 
-  // Construct a BrowserThread with the supplied identifier.  It is an error
-  // to construct a BrowserThread that already exists.
-  explicit BrowserThread(ID identifier);
-
-  // 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();
-
   // These are the same methods in message_loop.h, but are guaranteed to either
   // get posted to the MessageLoop if it's still alive, or be deleted otherwise.
   // They return true iff the thread existed and the task was posted.  Note that
   // even if the task is posted, there's no guarantee that it will run, since
   // the target thread may already have a Quit message in its queue.
   static bool PostTask(ID identifier,
                        const tracked_objects::Location& from_here,
                        const base::Closure& task);
   static bool PostDelayedTask(ID identifier,
                               const tracked_objects::Location& from_here,
@@ skipping 105 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);
+
+  // 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();
 
-  // TODO(brettw) remove this variant when Task->Closure migration is complete.
-  static bool PostTaskHelper(
-      ID identifier,
-      const tracked_objects::Location& from_here,
-      Task* task,
-      int64 delay_ms,
-      bool nestable);
-  static bool PostTaskHelper(
-      ID identifier,
-      const tracked_objects::Location& from_here,
-      const base::Closure& task,
-      int64 delay_ms,
-      bool nestable);
+  // 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_;
-
-  // This lock protects |browser_threads_|.  Do not read or modify that array
-  // without holding this lock.  Do not block while holding this lock.
-  static base::Lock lock_;
-
-  // An array of the BrowserThread 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.  BrowserThreads remove
-  // themselves from this array upon destruction.
-  static BrowserThread* browser_threads_[ID_COUNT];
 };
 
-#endif  // CONTENT_BROWSER_BROWSER_THREAD_H_
+// Temporary escape hatch for chrome/ to construct BrowserThread,
+// until we make content/ construct its own threads.
+class DeprecatedBrowserThread : public BrowserThread {
+ public:
+  explicit DeprecatedBrowserThread(BrowserThread::ID identifier);
+  DeprecatedBrowserThread(BrowserThread::ID identifier,
+                          MessageLoop* message_loop);
+  virtual ~DeprecatedBrowserThread();
+};
+
+#endif  // CONTENT_PUBLIC_BROWSER_BROWSER_THREAD_H_