Home | History | Annotate | Download | only in child 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CONTENT_CHILD_CHILD_PROCESS_H_
      6 #define CONTENT_CHILD_CHILD_PROCESS_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/synchronization/waitable_event.h"
     11 #include "base/threading/thread.h"
     12 #include "content/common/content_export.h"
     13 
     14 namespace content {
     15 class ChildThread;
     16 
     17 // Base class for child processes of the browser process (i.e. renderer and
     18 // plugin host). This is a singleton object for each child process.
     19 class CONTENT_EXPORT ChildProcess {
     20  public:
     21   // Child processes should have an object that derives from this class.
     22   // Normally you would immediately call set_main_thread after construction.
     23   ChildProcess();
     24   virtual ~ChildProcess();
     25 
     26   // May be NULL if the main thread hasn't been set explicitly.
     27   ChildThread* main_thread();
     28 
     29   // Sets the object associated with the main thread of this process.
     30   // Takes ownership of the pointer.
     31   void set_main_thread(ChildThread* thread);
     32 
     33   base::MessageLoop* io_message_loop() { return io_thread_.message_loop(); }
     34   base::MessageLoopProxy* io_message_loop_proxy() {
     35     return io_thread_.message_loop_proxy().get();
     36   }
     37 
     38   // A global event object that is signalled when the main thread's message
     39   // loop exits.  This gives background threads a way to observe the main
     40   // thread shutting down.  This can be useful when a background thread is
     41   // waiting for some information from the browser process.  If the browser
     42   // process goes away prematurely, the background thread can at least notice
     43   // the child processes's main thread exiting to determine that it should give
     44   // up waiting.
     45   // For example, see the renderer code used to implement
     46   // webkit_glue::GetCookies.
     47   base::WaitableEvent* GetShutDownEvent();
     48 
     49   // These are used for ref-counting the child process.  The process shuts
     50   // itself down when the ref count reaches 0.
     51   // For example, in the renderer process, generally each tab managed by this
     52   // process will hold a reference to the process, and release when closed.
     53   void AddRefProcess();
     54   void ReleaseProcess();
     55 
     56   // Getter for the one ChildProcess object for this process. Can only be called
     57   // on the main thread.
     58   static ChildProcess* current();
     59 
     60   static void WaitForDebugger(const std::string& label);
     61  private:
     62   int ref_count_;
     63 
     64   // An event that will be signalled when we shutdown.
     65   base::WaitableEvent shutdown_event_;
     66 
     67   // The thread that handles IO events.
     68   base::Thread io_thread_;
     69 
     70   // NOTE: make sure that main_thread_ is listed after shutdown_event_, since
     71   // it depends on it (indirectly through IPC::SyncChannel).  Same for
     72   // io_thread_.
     73   scoped_ptr<ChildThread> main_thread_;
     74 
     75   DISALLOW_COPY_AND_ASSIGN(ChildProcess);
     76 };
     77 
     78 }  // namespace content
     79 
     80 #endif  // CONTENT_CHILD_CHILD_PROCESS_H_
     81