GPU service respects --single-process

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"
 #include "base/string_piece.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/gpu_blacklist.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 #include "chrome/browser/renderer_host/render_message_filter.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_feature_flags.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/gpu/gpu_thread.h"
 #include "grit/browser_resources.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_LINUX)
 // These two #includes need to come after render_messages.h.
 #include <gdk/gdkwindow.h>  // NOLINT
 #include <gdk/gdkx.h>  // NOLINT
 #include "app/x11_util.h"
@@ skipping 41 matching lines @@
 // Once this limit is reached, any request to launch the gpu process will fail.
 static const int kGpuMaxCrashCount = 3;
 
 void RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new RouteOnUIThreadTask(message));
 }
 }  // anonymous namespace
 
+class GpuMainThread : public base::Thread {
+ public:
+  explicit GpuMainThread(const std::string& channel_id)
+      : base::Thread("CrGpuMain"),
+        channel_id_(channel_id) {
+  }
+
+  ~GpuMainThread() {
+    Stop();
+  }
+
+ protected:
+  virtual void Init() {
+    // Must be created on GPU thread.
+    gpu_thread_.reset(new GpuThread(channel_id_));
+    gpu_thread_->Init(base::Time::Now());
+  }
+
+  virtual void CleanUp() {
+    // Must be destroyed on GPU thread.
+    gpu_thread_.reset();
+  }
+
+ private:
+  scoped_ptr<GpuThread> gpu_thread_;
+  std::string channel_id_;
+  DISALLOW_COPY_AND_ASSIGN(GpuMainThread);
+};
+
 GpuProcessHost::GpuProcessHost()
     : BrowserChildProcessHost(GPU_PROCESS, NULL),
       initialized_(false),
       initialized_successfully_(false),
       blacklist_result_recorded_(false) {
   DCHECK_EQ(sole_instance_, static_cast<GpuProcessHost*>(NULL));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   while (!queued_synchronization_replies_.empty()) {
@@ skipping 440 matching lines @@
   }
   BrowserChildProcessHost::OnProcessCrashed(exit_code);
 }
 
 bool GpuProcessHost::CanLaunchGpuProcess() const {
   return RenderViewHostDelegateHelper::gpu_enabled();
 }
 
 bool GpuProcessHost::LaunchGpuProcess() {
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine::StringType gpu_launcher =
-      browser_command_line.GetSwitchValueNative(switches::kGpuLauncher);
 
-  FilePath exe_path = ChildProcessHost::GetChildPath(gpu_launcher.empty());
-  if (exe_path.empty())
-    return false;
+  // 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());
 
-  CommandLine* cmd_line = new CommandLine(exe_path);
-  cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
-  cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
+    base::Thread::Options options;
+    options.message_loop_type = MessageLoop::TYPE_UI;
 
-  // 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,
+    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;
+
+    CommandLine* cmd_line = new CommandLine(exe_path);
+    cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
+    cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id());
+
+    // 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(),
+#elif defined(OS_POSIX)
+        false,  // Never use the zygote (GPU plugin can't be sandboxed).
+        base::environment_vector(),
 #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(),
-#elif defined(OS_POSIX)
-      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;
 }