Launch processes asynchronously so as not to block the UI thread. For now, re...

chrome/browser/renderer_host/browser_render_process_host.h

 // Copyright (c) 2006-2008 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 CHROME_BROWSER_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_
 #define CHROME_BROWSER_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_
 
 #include "build/build_config.h"
 
 #include <map>
+#include <queue>
 #include <string>
 
 #include "base/process.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "chrome/common/transport_dib.h"
+#include "chrome/browser/child_process_launcher.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/common/notification_registrar.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebCache.h"
 
 class AudioRendererHost;
 class CommandLine;
 class GURL;
 class RendererMainThread;
 class RenderWidgetHelper;
 class TabContents;
@@ skipping 12 matching lines @@
 //
 // This object is refcounted so that it can release its resources when all
 // hosts using it go away.
 //
 // This object communicates back and forth with the RenderProcess object
 // running in the renderer process. Each RenderProcessHost and RenderProcess
 // keeps a list of RenderView (renderer) and TabContents (browser) which
 // are correlated with IDs. This way, the Views and the corresponding ViewHosts
 // communicate through the two process objects.
 class BrowserRenderProcessHost : public RenderProcessHost,
-                                 public NotificationObserver {
+                                 public NotificationObserver,
+                                 public ChildProcessLauncher::Client {
  public:
   explicit BrowserRenderProcessHost(Profile* profile);
   ~BrowserRenderProcessHost();
 
   // RenderProcessHost implementation (public portion).
   virtual bool Init(bool is_extensions_process,
                     URLRequestContextGetter* request_context);
   virtual int GetNextRoutingID();
   virtual void CancelResourceRequests(int render_widget_id);
   virtual void CrossSiteClosePageACK(const ViewMsg_ClosePage_Params& params);
   virtual bool WaitForPaintMsg(int render_widget_id,
                                const base::TimeDelta& max_delay,
                                IPC::Message* msg);
   virtual void ReceivedBadMessage(uint16 msg_type);
   virtual void WidgetRestored();
   virtual void WidgetHidden();
   virtual void ViewCreated();
   virtual void AddWord(const string16& word);
+  virtual void SendVisitedLinkTable(base::SharedMemory* table_memory);
   virtual void AddVisitedLinks(const VisitedLinkCommon::Fingerprints& links);
   virtual void ResetVisitedLinks();
   virtual bool FastShutdownIfPossible();
   virtual bool SendWithTimeout(IPC::Message* msg, int timeout_ms);
   virtual base::ProcessHandle GetHandle();
   virtual TransportDIB* GetTransportDIB(TransportDIB::Id dib_id);
 
   // IPC::Channel::Sender via RenderProcessHost.
   virtual bool Send(IPC::Message* msg);
 
   // IPC::Channel::Listener via RenderProcessHost.
   virtual void OnMessageReceived(const IPC::Message& msg);
   virtual void OnChannelConnected(int32 peer_pid);
   virtual void OnChannelError();
 
   // If the a process has sent a message that cannot be decoded, it is deemed
   // corrupted and thus needs to be terminated using this call. This function
   // can be safely called from any thread.
   static void BadMessageTerminateProcess(uint16 msg_type,
                                          base::ProcessHandle renderer);
 
   // NotificationObserver implementation.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
+  // ChildProcessLauncher::Client implementation.
+  virtual void OnProcessLaunched();
+
  private:
   friend class VisitRelayingRenderProcessHost;
 
   // Control message handlers.
   void OnPageContents(const GURL& url, int32 page_id,
                       const std::wstring& contents);
   void OnUpdatedCacheStats(const WebKit::WebCache::UsageStats& stats);
   void SuddenTerminationChanged(bool enabled);
   void OnExtensionAddListener(const std::string& event_name);
   void OnExtensionRemoveListener(const std::string& event_name);
   void OnExtensionCloseChannel(int port_id);
 
   // Initialize support for visited links. Send the renderer process its initial
   // set of visited links.
   void InitVisitedLinks();
 
   // Initialize support for user scripts. Send the renderer process its initial
   // set of scripts and listen for updates to scripts.
   void InitUserScripts();
 
   // Initialize support for extension APIs. Send the list of registered API
   // functions to thre renderer process.
   void InitExtensions();
 
   // Sends the renderer process a new set of user scripts.
   void SendUserScriptsUpdate(base::SharedMemory* shared_memory);
 
   // Generates a command line to be used to spawn a renderer and appends the
-  // results to |*command_line|. |*has_cmd_prefix| will be set if the renderer
-  // command line specifies a prefix which is another program that will actually
-  // execute the renderer (like gdb).
-  void AppendRendererCommandLine(CommandLine* command_line,
-                                 bool* has_cmd_prefix) const;
+  // results to |*command_line|.
+  void AppendRendererCommandLine(CommandLine* command_line) const;
 
   // Copies applicable command line switches from the given |browser_cmd| line
   // flags to the output |renderer_cmd| line flags. Not all switches will be
   // copied over.
   void PropogateBrowserCommandLineToRenderer(const CommandLine& browser_cmd,
                                              CommandLine* renderer_cmd) const;
 
-  // Spawns the renderer process, returning the new handle on success, or 0 on
-  // failure. The renderer command line is given in the first argument, and
-  // whether a command prefix was used when generating the command line is
-  // speficied in the second.
-  base::ProcessHandle ExecuteRenderer(CommandLine* cmd_line,
-                                      bool has_cmd_prefix);
-
   // Callers can reduce the RenderProcess' priority.
   // Returns true if the priority is backgrounded; false otherwise.
   void SetBackgrounded(bool boost);
 
 #if defined(SPELLCHECKER_IN_RENDERER)
   // The renderer has requested that we initialize its spellchecker. This should
   // generally only be called once per session, as after the first call, all
   // future renderers will be passed the initialization information on startup
   // (or when the dictionary changes in some way).
   void OnSpellCheckerRequestDictionary();
@@ skipping 40 matching lines @@
   void ClearTransportDIBCache();
   // This is used to clear our cache five seconds after the last use.
   base::DelayTimer<BrowserRenderProcessHost> cached_dibs_cleaner_;
 
   // Used in single-process mode.
   scoped_ptr<RendererMainThread> in_process_renderer_;
 
   // Buffer visited links and send them to to renderer.
   scoped_ptr<VisitedLinkUpdater> visited_link_updater_;
 
-  // True iff the renderer is a child of a zygote process.
-  bool zygote_child_;
-
   // True iff this process is being used as an extension process. Not valid
   // when running in single-process mode.
   bool extension_process_;
 
-  base::Process process_;
+  // Usedt to launch and terminate the process without blocking the UI thread.
+  scoped_ptr<ChildProcessLauncher> child_process_;
 
+  // Messages we queue while waiting for the process handle.  We queue them here
+  // instead of in the channel so that we ensure they're sent after init related
+  // messages that are sent once the process handle is available.  This is
+  // because the queued messages may have dependencies on the init messages.
+  std::queue<IPC::Message*> queued_messages_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserRenderProcessHost);
 };
 
 #endif  // CHROME_BROWSER_RENDERER_HOST_BROWSER_RENDER_PROCESS_HOST_H_