Fix DirectX diagnostic collection for about:gpu page.

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2012 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 "content/browser/gpu/gpu_process_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 182 matching lines @@
   if (gpu_data_manager != NULL && !gpu_data_manager->GpuAccessAllowed())
     return NULL;
 
   // The current policy is to ignore the renderer ID and use a single GPU
   // process (the first valid host in the host-id map) for all renderers. Later
   // this will be extended to allow the use of multiple GPU processes.
   for (IDMap<GpuProcessHost>::iterator it(g_hosts_by_id.Pointer());
        !it.IsAtEnd(); it.Advance()) {
     GpuProcessHost *host = it.GetCurrentValue();
 
+    if (host->sandboxed() != (client_id != 0))
+      continue;
+
     if (HostIsValid(host))
       return host;
   }
 
   if (cause == content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH)
     return NULL;
 
   int host_id;
   host_id = ++g_last_host_id;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause",
                             cause,
                             content::CAUSE_FOR_GPU_LAUNCH_MAX_ENUM);
 
-  GpuProcessHost* host = new GpuProcessHost(host_id);
+  GpuProcessHost* host = new GpuProcessHost(host_id, client_id != 0);
   if (host->Init())
     return host;
 
   delete host;
   return NULL;
 }
 
 // static
 void GpuProcessHost::SendOnIO(int client_id,
                               content::CauseForGpuLaunch cause,
@@ skipping 11 matching lines @@
   if (host_id == 0)
     return NULL;
 
   GpuProcessHost *host = g_hosts_by_id.Pointer()->Lookup(host_id);
   if (HostIsValid(host))
     return host;
 
   return NULL;
 }
 
-GpuProcessHost::GpuProcessHost(int host_id)
+GpuProcessHost::GpuProcessHost(int host_id, bool sandboxed)
     : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       in_process_(false),
-      software_rendering_(false) {
+      software_rendering_(false),
+      sandboxed_(sandboxed) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     in_process_ = true;
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
   DCHECK(!in_process_ || g_hosts_by_id.Pointer()->IsEmpty());
 
   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
 
@@ skipping 247 matching lines @@
   if (++g_gpu_crash_count >= kGpuMaxCrashCount) {
     // The gpu process is too unstable to use. Disable it for current session.
     gpu_enabled_ = false;
   }
 }
 
 bool GpuProcessHost::software_rendering() {
   return software_rendering_;
 }
 
+bool GpuProcessHost::sandboxed() {
+  return sandboxed_;
+}
+
 void GpuProcessHost::ForceShutdown() {
   g_hosts_by_id.Pointer()->Remove(host_id_);
   process_->ForceShutdown();
 }
 
 bool GpuProcessHost::LaunchGpuProcess(const std::string& channel_id) {
   if (!gpu_enabled_ || g_gpu_crash_count >= kGpuMaxCrashCount) {
     SendOutstandingReplies();
     gpu_enabled_ = false;
     return false;
@@ skipping 12 matching lines @@
 #endif
 
   FilePath exe_path = ChildProcessHost::GetChildPath(child_flags);
   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);
 
+  if (!sandboxed_)
+    cmd_line->AppendSwitch(switches::kDisableGpuSandbox);
+
   // Propagate relevant command line switches.
   static const char* const kSwitchNames[] = {
     switches::kDisableBreakpad,
     switches::kDisableGLMultisampling,
     switches::kDisableGpuDriverBugWorkarounds,
     switches::kDisableGpuSandbox,
     switches::kDisableGpuVsync,
     switches::kDisableGpuWatchdog,
     switches::kDisableImageTransportSurface,
     switches::kDisableLogging,
@@ skipping 58 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }