1 files changed, 34 insertions, 44 deletions

diff --git a/chrome/common/child_process.h b/chrome/common/child_process.h
index 4a63efb..90f31c5 100644
--- a/chrome/common/child_process.h
+++ b/chrome/common/child_process.h
@@ -7,45 +7,26 @@
 
 #include <string>
 #include <vector>
+#include "base/atomic_ref_count.h"
 #include "base/basictypes.h"
 #include "base/message_loop.h"
+#include "base/scoped_ptr.h"
+#include "base/waitable_event.h"
 
-namespace base {
-  class WaitableEvent;
-};
-
-class ChildProcess;
+class ChildThread;
 
-class ChildProcessFactoryInterface {
- public:
-  virtual ChildProcess* Create(const std::wstring& channel_name) = 0;
-};
-
-template<class T>
-class ChildProcessFactory : public ChildProcessFactoryInterface {
-  virtual ChildProcess* Create(const std::wstring& channel_name) {
-    return new T(channel_name);
-  }
-};
 
 // Base class for child processes of the browser process (i.e. renderer and
 // plugin host). This is a singleton object for each child process.
 class ChildProcess {
  public:
+  // Child processes should have an object that derives from this class.  The
+  // constructor will return once ChildThread has started.
+  ChildProcess(ChildThread* child_thread);
+  virtual ~ChildProcess();
 
-  // initializes/cleansup the global variables, services, and libraries
-  // Derived classes need to implement a static GlobalInit, that calls
-  // into ChildProcess::GlobalInit with a class factory
-//static bool GlobalInit(const std::wstring& channel_name);
-  static void GlobalCleanup();
-
-  // These are used for ref-counting the child process.  The process shuts
-  // itself down when the ref count reaches 0.  These functions may be called
-  // on any thread.
-  // For example, in the renderer process, generally each tab managed by this
-  // process will hold a reference to the process, and release when closed.
-  static void AddRefProcess();
-  static void ReleaseProcess();
+  // Getter for this process' main thread.
+  ChildThread* child_thread() { return child_thread_.get(); }
 
   // A global event object that is signalled when the main thread's message
   // loop exits.  This gives background threads a way to observe the main
@@ -56,22 +37,24 @@ class ChildProcess {
   // up waiting.
   // For example, see the renderer code used to implement
   // webkit_glue::GetCookies.
-  static base::WaitableEvent* GetShutDownEvent();
+  base::WaitableEvent* GetShutDownEvent();
 
-  // You must call Init after creating this object before it will be valid
-  ChildProcess();
-  virtual ~ChildProcess();
+  // These are used for ref-counting the child process.  The process shuts
+  // itself down when the ref count reaches 0.  These functions may be called
+  // on any thread.
+  // For example, in the renderer process, generally each tab managed by this
+  // process will hold a reference to the process, and release when closed.
+  void AddRefProcess();
+  void ReleaseProcess();
 
  protected:
-  static bool GlobalInit(const std::wstring& channel_name,
-                         ChildProcessFactoryInterface* factory);
-
-  static bool ProcessRefCountIsZero();
+  friend class ChildThread;
 
-  // The singleton instance for this process.
-  static ChildProcess* child_process_;
+  // Getter for the one ChildProcess object for this process.
+  static ChildProcess* current() { return child_process_; }
 
-  static MessageLoop* main_thread_loop_;
+ protected:
+  bool ProcessRefCountIsZero();
 
   // Derived classes can override this to alter the behavior when the ref count
   // reaches 0. The default implementation calls Quit on the main message loop
@@ -80,10 +63,17 @@ class ChildProcess {
   virtual void OnFinalRelease();
 
  private:
-  // Derived classes can override this to handle any cleanup, called by
-  // GlobalCleanup.
-  virtual void Cleanup() {}
-  static base::WaitableEvent* shutdown_event_;
+  // NOTE: make sure that child_thread_ is listed before shutdown_event_, since
+  // it depends on it (indirectly through IPC::SyncChannel).
+  scoped_ptr<ChildThread> child_thread_;
+
+  base::AtomicRefCount ref_count_;
+
+  // An event that will be signalled when we shutdown.
+  base::WaitableEvent shutdown_event_;
+
+  // The singleton instance for this process.
+  static ChildProcess* child_process_;
 
   DISALLOW_EVIL_CONSTRUCTORS(ChildProcess);
 };