Refactor code from RenderThread and PluginThread and move it to ChildThread. ChildProcess now owns the ChildThread, which removes duplicate code and simplifies things.

Clean up ChildProcess, there really was no need for all the templates and statics in it and its subclasses.

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=10080
Review URL: http://codereview.chromium.org/21502

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@10144 0039d316-1c4b-4281-b951-d872f2087c98

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);
 };