GPU service respects --single-process

chrome/gpu/gpu_thread.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/gpu/gpu_thread.h"
 
 #include <string>
 #include <vector>
 
 #include "app/gfx/gl/gl_context.h"
@@ skipping 26 matching lines @@
   return sandbox_wrapper.InitializeSandbox(*parsed_command_line,
                                            switches::kGpuProcess);
 #else
   // TODO(port): Create GPU sandbox for linux and windows.
   return true;
 #endif
 }
 
 }  // namespace
 
-GpuThread::GpuThread(const CommandLine& command_line)
-    : command_line_(command_line) {}
+GpuThread::GpuThread() {
+}
+
+GpuThread::GpuThread(const std::string& channel_id)
+    : ChildThread(channel_id) {
+}
 
 GpuThread::~GpuThread() {
 }
 
 void GpuThread::Init(const base::Time& process_start_time) {
   process_start_time_ = process_start_time;
 }
 
 void GpuThread::RemoveChannel(int renderer_id) {
   gpu_channels_.erase(renderer_id);
@@ skipping 42 matching lines @@
     // Flag GPU info as complete if the DirectX diagnostics cannot be collected.
     gpu_info_.SetProgress(GPUInfo::kComplete);
   }
 #endif
 
   // Record initialization only after collecting the GPU info because that can
   // take a significant amount of time.
   gpu_info_.SetInitializationTime(base::Time::Now() - process_start_time_);
 
   // Note that kNoSandbox will also disable the GPU sandbox.
-  bool no_gpu_sandbox = command_line_.HasSwitch(switches::kNoGpuSandbox);
+  bool no_gpu_sandbox = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kNoGpuSandbox);
   if (!no_gpu_sandbox) {
     if (!InitializeGpuSandbox()) {
       LOG(ERROR) << "Failed to initialize the GPU sandbox";
       MessageLoop::current()->Quit();
       return;
     }
   } else {
     LOG(ERROR) << "Running without GPU sandbox";
   }
 
   // In addition to disabling the watchdog if the command line switch is
   // present, disable it in two other cases. OSMesa is expected to run very
   // slowly.  Also disable the watchdog on valgrind because the code is expected
   // to run slowly in that case.
   bool enable_watchdog =
-      !command_line_.HasSwitch(switches::kDisableGpuWatchdog) &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableGpuWatchdog) &&
       gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL &&
       !RunningOnValgrind();
 
   // Disable the watchdog in debug builds because they tend to only be run by
   // developers who will not appreciate the watchdog killing the GPU process.
 #ifndef NDEBUG
   enable_watchdog = false;
 #endif
 
   // Disable the watchdog for Windows. It tends to abort when the GPU process
@@ skipping 19 matching lines @@
   }
 }
 
 void GpuThread::OnEstablishChannel(int renderer_id) {
   scoped_refptr<GpuChannel> channel;
   IPC::ChannelHandle channel_handle;
   GPUInfo gpu_info;
 
   GpuChannelMap::const_iterator iter = gpu_channels_.find(renderer_id);
   if (iter == gpu_channels_.end())
-    channel = new GpuChannel(renderer_id);
+    channel = new GpuChannel(this, renderer_id);
   else
     channel = iter->second;
 
   DCHECK(channel != NULL);
 
   if (channel->Init())
     gpu_channels_[renderer_id] = channel;
   else
     channel = NULL;
 
@@ skipping 75 matching lines @@
       NewRunnableFunction(&GpuThread::SetDxDiagnostics, thread, node));
 }
 
 // Runs on the GPU thread.
 void GpuThread::SetDxDiagnostics(GpuThread* thread, const DxDiagNode& node) {
   thread->gpu_info_.SetDxDiagnostics(node);
   thread->gpu_info_.SetProgress(GPUInfo::kComplete);
 }
 
 #endif