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()) {
+      // Collect information about the GPU.
+      if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_)) {
+        LOG(INFO) << "gpu_info_collector::CollectGraphicsInfo failed";

[jochen (gone - plz use gerrit), 2012/05/16 07:34:19]

please use VLOG(1) instead of LOG(INFO)

+      }
+
+#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) {
+          LOG(INFO) << "NVIDIA device file /dev/nvidiactl access denied";
+          gpu_info_.gpu_accessible = false;
+        }
+      }
+#endif
+    } else {
+      LOG(INFO) << "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";
   if (gpu_channel_manager_.get())
     gpu_channel_manager_->LoseAllContexts();
@@ skipping 29 matching lines @@
 // 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