Switch the first thread in a child process to be the main thread...

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2009 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 36 matching lines @@
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/chrome_descriptors.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/renderer/render_process.h"
+#include "chrome/renderer/render_thread.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "grit/generated_resources.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #include "chrome/browser/sandbox_policy.h"
 #elif defined(OS_LINUX)
 #include "base/linux_util.h"
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_crash_handler_host_linux.h"
@@ skipping 18 matching lines @@
   ~RendererMainThread() {
     Stop();
   }
 
  protected:
   virtual void Init() {
 #if defined(OS_WIN)
     CoInitialize(NULL);
 #endif
 
-    render_process_ = new RenderProcess(channel_id_);
+    render_process_ = new RenderProcess();
+    render_process_->set_main_thread(new RenderThread(channel_id_));
     // It's a little lame to manually set this flag.  But the single process
     // RendererThread will receive the WM_QUIT.  We don't need to assert on
     // this thread, so just force the flag manually.
     // If we want to avoid this, we could create the InProcRendererThread
     // directly with _beginthreadex() rather than using the Thread class.
     base::Thread::SetThreadWasQuitProperly(true);
   }
 
   virtual void CleanUp() {
     delete render_process_;
@@ skipping 298 matching lines @@
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
   if (!profile_path.empty())
     cmd_line.AppendSwitchWithValue(switches::kUserDataDir,
                                    profile_path);
 
   if (run_renderer_in_process()) {
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
-    // to prevent a deadlock in single-process mode.  When using multiple
-    // processes, the primordial thread in the renderer process has a message
-    // loop which is used for sending messages asynchronously to the io thread
-    // in the browser process.  If we don't create this thread, then the
-    // RenderThread is both responsible for rendering and also for
-    // communicating IO.  This can lead to deadlocks where the RenderThread is
-    // waiting for the IO to complete, while the browsermain is trying to pass
-    // an event to the RenderThread.
+    // to prevent a deadlock in single-process mode.  Since the primordial
+    // thread in the renderer process runs the WebKit code and can sometimes
+    // blocking calls to the UI thread (i.e. this thread), they need to run on
+    // separate threads.
     in_process_renderer_.reset(new RendererMainThread(channel_id));
 
     base::Thread::Options options;
-    options.message_loop_type = MessageLoop::TYPE_IO;
+    options.message_loop_type = MessageLoop::TYPE_UI;

[Evan Martin, 2009/07/27 22:01:31]

This seems to have broken --single-process on Linux, since we can only have one
UI message loop per process.  (And even in multi-proc, our renderers don't have
access to UI stuff, so they shouldn't be UI loops anyway.)

     in_process_renderer_->StartWithOptions(options);
   } else {
     base::ProcessHandle process = 0;
 #if defined(OS_WIN)
     process = sandbox::StartProcess(&cmd_line);
 #elif defined(OS_POSIX)
 #if defined(OS_LINUX)
     if (!has_cmd_prefix) {
       base::GlobalDescriptors::Mapping mapping;
       const int ipcfd = channel_->GetClientFileDescriptor();
@@ skipping 539 matching lines @@
     profile()->GetExtensionMessageService()->RemoveEventListener(event_name,
                                                                  pid());
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->CloseChannel(port_id);
   }
 }