Disabled support for running GPU thread in browser process with --single-proc...

chrome/browser/gpu_process_host.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 556 matching lines @@
   BrowserChildProcessHost::OnProcessCrashed(exit_code);
 }
 
 bool GpuProcessHost::CanLaunchGpuProcess() const {
   return RenderViewHostDelegateHelper::gpu_enabled();
 }
 
 bool GpuProcessHost::LaunchGpuProcess() {
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
 
+  // TODO(apatrick): glib is not thread safe and the GPU thread needs to pump
+  // the message loop for the CPU child window. A long-term fix might be to make

[jonathan.backer, 2011/01/14 19:30:30]

I don't think that we need to run a UI thread for message pumping: I ran the gpu
process as a separate process, but changed the type to an IO message pump in
gpu_main.cc, and it seemed to work just fine.

+  // the browser process responsible for presenting frames and eliminate the
+  // GPU child window so the GPU thread can run in the browser process.

[jonathan.backer, 2011/01/14 19:30:30]

The way that the code currently works (it has changed a few times now ;-D --- by
my own hand) is that the GPU child window is "owned" by the browser.
Modifications to this window have to go through the browser (for example window
resizes end up at the GPU through the glResizeCHROMIUM command, which is finally
acted on in the browser via a sync IPC call). This is very different from the
windows code.

My current hypothesis about the problem is that X is not thread safe. This is
consistent with part of the browser architecture: it has two connections to the
X server -- one on the UI thread and one on the BACKGROUND_X11 thread. The
purpose of the second thread is to quickly answer some geometry requests from
the renderer. The fact that we need two connections says to me that a single
connection is not thread safe.

I would rephrase the TODO:
This cannot be a UI message pump on Linux because glib is not thread safe.
Changing this to an IO message pump does not completely resolve the problem,
most likely because we're sharing a connection to the X server with the browser.

+#if !defined(OS_LINUX)
+
   // If the single-process switch is present, just launch the GPU service in a
   // new thread in the browser process.
   if (browser_command_line.HasSwitch(switches::kSingleProcess)) {
     GpuMainThread* thread = new GpuMainThread(channel_id());
 
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_UI;
 
     if (!thread->StartWithOptions(options))
       return false;
-  } else {
-    CommandLine::StringType gpu_launcher =
-        browser_command_line.GetSwitchValueNative(switches::kGpuLauncher);
 
-    FilePath exe_path = ChildProcessHost::GetChildPath(gpu_launcher.empty());
-    if (exe_path.empty())
-      return false;
+    return true;
+  }
+#endif
 
-    CommandLine* cmd_line = new CommandLine(exe_path);
-    cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
-    cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
+  CommandLine::StringType gpu_launcher =
+      browser_command_line.GetSwitchValueNative(switches::kGpuLauncher);
 
-    // Propagate relevant command line switches.
-    static const char* const kSwitchNames[] = {
-      switches::kUseGL,
-      switches::kDisableGpuVsync,
-      switches::kDisableGpuWatchdog,
-      switches::kDisableLogging,
-      switches::kEnableAcceleratedDecoding,
-      switches::kEnableLogging,
-  #if defined(OS_MACOSX)
-      switches::kEnableSandboxLogging,
-  #endif
-      switches::kGpuStartupDialog,
-      switches::kLoggingLevel,
-      switches::kNoGpuSandbox,
-      switches::kNoSandbox,
-    };
-    cmd_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
-                               arraysize(kSwitchNames));
+  FilePath exe_path = ChildProcessHost::GetChildPath(gpu_launcher.empty());
+  if (exe_path.empty())
+    return false;
 
-    // If specified, prepend a launcher program to the command line.
-    if (!gpu_launcher.empty())
-      cmd_line->PrependWrapper(gpu_launcher);
+  CommandLine* cmd_line = new CommandLine(exe_path);
+  cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
+  cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
 
-    Launch(
+  // Propagate relevant command line switches.
+  static const char* const kSwitchNames[] = {
+    switches::kUseGL,
+    switches::kDisableGpuVsync,
+    switches::kDisableGpuWatchdog,
+    switches::kDisableLogging,
+    switches::kEnableAcceleratedDecoding,
+    switches::kEnableLogging,
+#if defined(OS_MACOSX)
+    switches::kEnableSandboxLogging,
+#endif
+    switches::kGpuStartupDialog,
+    switches::kLoggingLevel,
+    switches::kNoGpuSandbox,
+    switches::kNoSandbox,
+  };
+  cmd_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
+                             arraysize(kSwitchNames));
+
+  // If specified, prepend a launcher program to the command line.
+  if (!gpu_launcher.empty())
+    cmd_line->PrependWrapper(gpu_launcher);
+
+  Launch(
 #if defined(OS_WIN)
-        FilePath(),
+      FilePath(),
 #elif defined(OS_POSIX)
-        false,  // Never use the zygote (GPU plugin can't be sandboxed).
-        base::environment_vector(),
+      false,  // Never use the zygote (GPU plugin can't be sandboxed).
+      base::environment_vector(),
 #endif
-        cmd_line);
-  }
+      cmd_line);
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLifetimeEvents",
                             LAUNCED, GPU_PROCESS_LIFETIME_EVENT_MAX);
   return true;
 }
 
 bool GpuProcessHost::LoadGpuBlacklist() {
   if (gpu_blacklist_.get() != NULL)
     return true;
   static const base::StringPiece gpu_blacklist_json(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_GPU_BLACKLIST));
   GpuBlacklist* blacklist = new GpuBlacklist();
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) ||
       blacklist->LoadGpuBlacklist(gpu_blacklist_json.as_string(), true)) {
     gpu_blacklist_.reset(blacklist);
     return true;
   }
   delete blacklist;
   return false;
 }