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"
 #include "base/command_line.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/common/child_process.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/gpu/gpu_info_collector.h"
 #include "content/gpu/gpu_watchdog_thread.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ui/gl/gl_implementation.h"
 
 const int kGpuTimeout = 10000;
 
 namespace {
 
 bool GpuProcessLogMessageHandler(int severity,
@@ skipping 29 matching lines @@
 #endif
 }
 
 GpuChildThread::GpuChildThread(const std::string& channel_id)
     : ChildThread(channel_id),
       dead_on_arrival_(false) {
 #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;
 }
@@ skipping 20 matching lines @@
 
   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";
+    VLOG(1) << "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);
 
@@ skipping 35 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()));
 
+#if defined(OS_LINUX)
   // Ensure the browser process receives the GPU info before a reply to any
   // subsequent IPC it might send.
   Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
+#endif
 }
 
 void GpuChildThread::StopWatchdog() {
   if (watchdog_thread_.get()) {
     watchdog_thread_->Stop();
   }
 }
 
 void GpuChildThread::OnCollectGraphicsInfo() {
+  if (!gpu_info_.finalized &&
+      CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableGpuSandbox)) {
+    // GPU full info collection should only happen on un-sandboxed GPU process.
+
+    if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_))
+      VLOG(1) << "gpu_info_collector::CollectGraphicsInfo failed";
+    content::GetContentClient()->SetGpuInfo(gpu_info_);
+
 #if defined(OS_WIN)
-  if (!gpu_info_.finalized && !collecting_dx_diagnostics_) {
-    // Prevent concurrent collection of DirectX diagnostics.
-    collecting_dx_diagnostics_ = true;
+    if (!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;
       }
     }
+#endif
   }
-#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