Only collect GL/D3D context specific GPUInfo in GPU process

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 56 matching lines @@
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU)) {
     // For single process and in-process GPU mode, we need to load and
     // initialize the GL implementation and locate the GL entry points here.
     if (!gfx::GLSurface::InitializeOneOff()) {
       VLOG(1) << "gfx::GLSurface::InitializeOneOff()";
     }
   }
 }
 
-
 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 39 matching lines @@
   // 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_;
 
-
   // 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 defined(OS_WIN)
   // GPU full info collection should only happen on un-sandboxed GPU process
   // or single process/in-process gpu mode on Windows.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   DCHECK(command_line->HasSwitch(switches::kDisableGpuSandbox) ||
          command_line->HasSwitch(switches::kSingleProcess) ||
          command_line->HasSwitch(switches::kInProcessGPU));
 #endif  // OS_WIN
 
   // Sandbox state is not part of the gpu info collection.  It is determined
   // in GpuMain() and passed down to GpuChildThread.

[Ken Russell (switch to Gerrit), 2012/12/15 00:33:56]

Is this comment still relevant?

-  bool sandboxed = gpu_info_.sandboxed;
-  if (!gpu_info_collector::CollectGraphicsInfo(&gpu_info_))
+  if (!gpu_info_collector::CollectContextGraphicsInfo(&gpu_info_))
     VLOG(1) << "gpu_info_collector::CollectGraphicsInfo failed";
-  gpu_info_.sandboxed = sandboxed;
   GetContentClient()->SetGpuInfo(gpu_info_);
 
 #if defined(OS_WIN)
   // This is slow, but it's the only thing the unsandboxed GPU process does,
   // and GpuDataManager prevents us from sending multiple collecting requests,
   // so it's OK to be blocking.
   gpu_info_collector::GetDxDiagnostics(&gpu_info_.dx_diagnostics);
   gpu_info_.finalized = true;
 #endif  // OS_WIN
 
@@ skipping 49 matching lines @@
     // the future posting of tasks to the message loop.
     if (watchdog_thread_->message_loop())
       watchdog_thread_->PostAcknowledge();
     // Prevent rearming.
     watchdog_thread_->Stop();
   }
 }
 
 }  // namespace content