Disable GPU info collection on GPU process startup on Win/Mac.

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 29 matching lines @@
   } else {
     ChildThread::current()->Send(new GpuHostMsg_OnLogMessage(severity, header,
         message));
   }
 
   return false;
 }
 
 }  // namespace
 
-GpuChildThread::GpuChildThread(bool dead_on_arrival,
-                               const content::GPUInfo& gpu_info)
-    : dead_on_arrival_(dead_on_arrival),
-      gpu_info_(gpu_info) {
+GpuChildThread::GpuChildThread() {
 #if defined(OS_WIN)
   target_services_ = NULL;
   collecting_dx_diagnostics_ = false;
 #endif
 }
 
 GpuChildThread::GpuChildThread(const std::string& channel_id)
-    : ChildThread(channel_id),
-      dead_on_arrival_(false) {
+    : ChildThread(channel_id) {
 #if defined(OS_WIN)
   target_services_ = NULL;
   collecting_dx_diagnostics_ = false;
 #endif
-  if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_)) {
-    LOG(INFO) << "gpu_info_collector::CollectGraphicsInfo failed";
-  }
 }
 
-
 GpuChildThread::~GpuChildThread() {
   logging::SetLogMessageHandler(NULL);
 }
 
 void GpuChildThread::Init(const base::Time& process_start_time) {
   process_start_time_ = process_start_time;
 }
 
 bool GpuChildThread::Send(IPC::Message* msg) {
   // The GPU process must never send a synchronous IPC message to the browser
@@ skipping 16 matching lines @@
   IPC_END_MESSAGE_MAP_EX()
 
   if (handled)
     return true;
 
   return gpu_channel_manager_.get() &&
       gpu_channel_manager_->OnMessageReceived(msg);
 }
 
 void GpuChildThread::OnInitialize() {
-  if (dead_on_arrival_) {
-    LOG(INFO) << "Exiting GPU process due to errors during initialization";
-    MessageLoop::current()->Quit();
-    return;
-  }
-
   // We don't need to pipe log messages if we are running the GPU thread in
   // the browser process.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
 
   // Record initialization only after collecting the GPU info because that can
   // take a significant amount of time.
   gpu_info_.initialization_time = base::Time::Now() - process_start_time_;
 
@@ skipping 31 matching lines @@
 
   // Defer creation of the render thread. This is to prevent it from handling
   // IPC messages before the sandbox has been enabled and all other necessary
   // initialization has succeeded.
   gpu_channel_manager_.reset(new GpuChannelManager(
       this,
       watchdog_thread_,
       ChildProcess::current()->io_message_loop_proxy(),
       ChildProcess::current()->GetShutDownEvent()));
 
-  // Ensure the browser process receives the GPU info before a reply to any
-  // subsequent IPC it might send.
-  Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
+#if defined(OS_LINUX)
+  OnCollectGraphicsInfo();
+#endif
 }
 
 void GpuChildThread::StopWatchdog() {
   if (watchdog_thread_.get()) {
     watchdog_thread_->Stop();
   }
 }
 
 void GpuChildThread::OnCollectGraphicsInfo() {
+  DCHECK(CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kDisableGpuSandbox));
+  if (!gpu_info_.finalized) {
+    // Load and initialize the GL implementation and locate the GL entry points.
+    if (gfx::GLSurface::InitializeOneOff()) {

[apatrick_chromium, 2012/05/16 18:02:35]

At this point, the GPU sandbox might have been turned on and this function will
sometimes fail on Windows. That's why it happens in GpuMain. Whether this will
work depends on whether this code runs in the "sandboxed" or "unsandboxed" GPU
process. Can you clarify which of the two this IPC handler will run in?

+      // Collect information about the GPU.
+      if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_)) {

[apatrick_chromium, 2012/05/16 18:02:35]

.. ditto this.

+        VLOG(1) << "gpu_info_collector::CollectGraphicsInfo failed";
+      }
+
+#if defined(OS_LINUX)
+      if (gpu_info_.gpu.vendor_id == 0x10de &&  // NVIDIA
+          gpu_info_.driver_vendor == "NVIDIA") {
+        base::ThreadRestrictions::AssertIOAllowed();
+        if (access("/dev/nvidiactl", R_OK) != 0) {

[apatrick_chromium, 2012/05/16 18:02:35]

... and I suspect this might fail on Linux once the GPU sandbox is enabled on
Linux.

+          VLOG(1) << "NVIDIA device file /dev/nvidiactl access denied";
+          gpu_info_.gpu_accessible = false;
+        }
+      }
+#endif
+    } else {
+      VLOG(1) << "gfx::GLSurface::InitializeOneOff failed";
+      gpu_info_.gpu_accessible = false;
+    }
+#if !defined(OS_WIN)
+    gpu_info_.finalized = true;
+#endif
+  }
 #if defined(OS_WIN)
   if (!gpu_info_.finalized && !collecting_dx_diagnostics_) {
     // Prevent concurrent collection of DirectX diagnostics.
     collecting_dx_diagnostics_ = true;
 
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kDisableGpuSandbox)) {
-      // Asynchronously collect the DirectX diagnostics because this can take a
-      // couple of seconds.
-      if (!base::WorkerPool::PostTask(
-          FROM_HERE, base::Bind(&GpuChildThread::CollectDxDiagnostics, this),
-          true)) {
-        // Flag GPU info as complete if the DirectX diagnostics cannot be
-        // collected.
-        collecting_dx_diagnostics_ = false;
-        gpu_info_.finalized = true;
-      } else {
-        // Do not send response if we are still completing the GPUInfo struct
-        return;
-      }
+    // Asynchronously collect the DirectX diagnostics because this can take a
+    // couple of seconds.
+    if (!base::WorkerPool::PostTask(
+        FROM_HERE, base::Bind(&GpuChildThread::CollectDxDiagnostics, this),
+        true)) {
+      // Flag GPU info as complete if the DirectX diagnostics cannot be
+      // collected.
+      collecting_dx_diagnostics_ = false;
+      gpu_info_.finalized = true;
     }
   }
 #endif
   Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
 }
 
 void GpuChildThread::OnClean() {
-  LOG(INFO) << "GPU: Removing all contexts";
+  VLOG(1) << "GPU: Removing all contexts";
   if (gpu_channel_manager_.get())
     gpu_channel_manager_->LoseAllContexts();
 }
 
 void GpuChildThread::OnCrash() {
-  LOG(INFO) << "GPU: Simulating GPU crash";
+  VLOG(1) << "GPU: Simulating GPU crash";
   // Good bye, cruel world.
   volatile int* it_s_the_end_of_the_world_as_we_know_it = NULL;
   *it_s_the_end_of_the_world_as_we_know_it = 0xdead;
 }
 
 void GpuChildThread::OnHang() {
-  LOG(INFO) << "GPU: Simulating GPU hang";
+  VLOG(1) << "GPU: Simulating GPU hang";
   for (;;) {
     // Do not sleep here. The GPU watchdog timer tracks the amount of user
     // time this thread is using and it doesn't use much while calling Sleep.
   }
 }
 
 #if defined(OS_WIN)
 
 // Runs on a worker thread. The GPU process never terminates voluntarily so
 // it is safe to assume that its message loop is valid.
 void GpuChildThread::CollectDxDiagnostics(GpuChildThread* thread) {
   content::DxDiagNode node;
   gpu_info_collector::GetDxDiagnostics(&node);
 
   thread->message_loop()->PostTask(
       FROM_HERE, base::Bind(&GpuChildThread::SetDxDiagnostics, thread, node));
 }
 
 // Runs on the main thread.
 void GpuChildThread::SetDxDiagnostics(GpuChildThread* thread,
                                       const content::DxDiagNode& node) {
   thread->gpu_info_.dx_diagnostics = node;
   thread->gpu_info_.finalized = true;
   thread->collecting_dx_diagnostics_ = false;
   thread->Send(new GpuHostMsg_GraphicsInfoCollected(thread->gpu_info_));
 }
 
 #endif