Extract code into functions in GpuMain.

content/gpu/gpu_main.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 <stdlib.h>
 
 #if defined(OS_WIN)
 #include <dwmapi.h>
 #include <windows.h>
 #endif
@@ skipping 48 matching lines @@
 #if defined(ADDRESS_SANITIZER)
 #include <sanitizer/asan_interface.h>
 #endif
 
 const int kGpuTimeout = 10000;
 
 namespace content {
 
 namespace {
 
+void GetGpuInfoFromCommandLine(gpu::GPUInfo& gpu_info,
+                               const CommandLine& command_line);
 bool WarmUpSandbox(const CommandLine& command_line);
+
+#if !defined(OS_MACOSX)
+bool CollectGraphicsInfo(gpu::GPUInfo& gpu_info);
+#endif
+
 #if defined(OS_LINUX)
+#if !defined(OS_CHROMEOS)
+bool CanAccessNvidiaDeviceFile();
+#endif
 bool StartSandboxLinux(const gpu::GPUInfo&, GpuWatchdogThread*, bool);
 #elif defined(OS_WIN)
 bool StartSandboxWindows(const sandbox::SandboxInterfaceInfo*);
 #endif
 
 base::LazyInstance<GpuChildThread::DeferredMessages> deferred_messages =
     LAZY_INSTANCE_INITIALIZER;
 
 bool GpuProcessLogMessageHandler(int severity,
                                  const char* file, int line,
@@ skipping 113 matching lines @@
   // Start the GPU watchdog only after anything that is expected to be time
   // consuming has completed, otherwise the process is liable to be aborted.
   if (enable_watchdog && !delayed_watchdog_enable) {
     watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
     watchdog_thread->Start();
   }
 
   gpu::GPUInfo gpu_info;
   // Get vendor_id, device_id, driver_version from browser process through
   // commandline switches.
-  DCHECK(command_line.HasSwitch(switches::kGpuVendorID) &&
-         command_line.HasSwitch(switches::kGpuDeviceID) &&
-         command_line.HasSwitch(switches::kGpuDriverVersion));
-  bool success = base::HexStringToUInt(
-      command_line.GetSwitchValueASCII(switches::kGpuVendorID),
-      &gpu_info.gpu.vendor_id);
-  DCHECK(success);
-  success = base::HexStringToUInt(
-      command_line.GetSwitchValueASCII(switches::kGpuDeviceID),
-      &gpu_info.gpu.device_id);
-  DCHECK(success);
-  gpu_info.driver_vendor =
-      command_line.GetSwitchValueASCII(switches::kGpuDriverVendor);
-  gpu_info.driver_version =
-      command_line.GetSwitchValueASCII(switches::kGpuDriverVersion);
-  GetContentClient()->SetGpuInfo(gpu_info);
+  GetGpuInfoFromCommandLine(gpu_info, command_line);
 
   base::TimeDelta collect_context_time;
   base::TimeDelta initialize_one_off_time;
 
   // Warm up resources that don't need access to GPUInfo.
   if (WarmUpSandbox(command_line)) {
 #if defined(OS_LINUX)
     bool initialized_sandbox = false;
     bool initialized_gl_context = false;
     bool should_initialize_gl_context = false;
@@ skipping 36 matching lines @@
       // purposes. However, on Mac we don't actually use them. As documented in
       // crbug.com/222934, due to some driver issues, glGetString could take
       // multiple seconds to finish, which in turn cause the GPU process to
       // crash.
       // By skipping the following code on Mac, we don't really lose anything,
       // because the basic GPU information is passed down from browser process
       // and we already registered them through SetGpuInfo() above.
       base::TimeTicks before_collect_context_graphics_info =
           base::TimeTicks::Now();
 #if !defined(OS_MACOSX)
-      gpu::CollectInfoResult result =
-          gpu::CollectContextGraphicsInfo(&gpu_info);
-      switch (result) {
-        case gpu::kCollectInfoFatalFailure:
-          LOG(ERROR) << "gpu::CollectGraphicsInfo failed (fatal).";
-          dead_on_arrival = true;
-          break;
-        case gpu::kCollectInfoNonFatalFailure:
-          VLOG(1) << "gpu::CollectGraphicsInfo failed (non-fatal).";
-          break;
-        case gpu::kCollectInfoSuccess:
-          break;
-      }
-      GetContentClient()->SetGpuInfo(gpu_info);
+      if (!CollectGraphicsInfo(gpu_info))
+        dead_on_arrival = true;
 
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
       // Recompute gpu driver bug workarounds - this is specifically useful
       // on systems where vendor_id/device_id aren't available.
       if (!command_line.HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
         gpu::ApplyGpuDriverBugWorkarounds(
             gpu_info, const_cast<CommandLine*>(&command_line));
       }
 #endif
 
 #if defined(OS_LINUX)
       initialized_gl_context = true;
 #if !defined(OS_CHROMEOS)
       if (gpu_info.gpu.vendor_id == 0x10de &&  // NVIDIA
-          gpu_info.driver_vendor == "NVIDIA") {
-        base::ThreadRestrictions::AssertIOAllowed();
-        if (access("/dev/nvidiactl", R_OK) != 0) {
-          VLOG(1) << "NVIDIA device file /dev/nvidiactl access denied";
-          dead_on_arrival = true;
-        }
-      }
+          gpu_info.driver_vendor == "NVIDIA" &&
+          !CanAccessNvidiaDeviceFile())
+        dead_on_arrival = true;
 #endif  // !defined(OS_CHROMEOS)
 #endif  // defined(OS_LINUX)
 #endif  // !defined(OS_MACOSX)
       collect_context_time =
           base::TimeTicks::Now() - before_collect_context_graphics_info;
-    } else {
+    } else {  // gl_initialized
       VLOG(1) << "gfx::GLSurface::InitializeOneOff failed";
       dead_on_arrival = true;
     }
 
     initialize_one_off_time =
         base::TimeTicks::Now() - before_initialize_one_off;
 
     if (enable_watchdog && delayed_watchdog_enable) {
       watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
       watchdog_thread->Start();
@@ skipping 50 matching lines @@
     main_message_loop.Run();
   }
 
   child_thread->StopWatchdog();
 
   return 0;
 }
 
 namespace {
 
+void GetGpuInfoFromCommandLine(gpu::GPUInfo& gpu_info,
+                               const CommandLine& command_line) {
+  DCHECK(command_line.HasSwitch(switches::kGpuVendorID) &&
+         command_line.HasSwitch(switches::kGpuDeviceID) &&
+         command_line.HasSwitch(switches::kGpuDriverVersion));
+  bool success = base::HexStringToUInt(
+      command_line.GetSwitchValueASCII(switches::kGpuVendorID),
+      &gpu_info.gpu.vendor_id);
+  DCHECK(success);
+  success = base::HexStringToUInt(
+      command_line.GetSwitchValueASCII(switches::kGpuDeviceID),
+      &gpu_info.gpu.device_id);
+  DCHECK(success);
+  gpu_info.driver_vendor =
+      command_line.GetSwitchValueASCII(switches::kGpuDriverVendor);
+  gpu_info.driver_version =
+      command_line.GetSwitchValueASCII(switches::kGpuDriverVersion);
+  GetContentClient()->SetGpuInfo(gpu_info);
+}
+
+bool WarmUpSandbox(const CommandLine& command_line) {
+  {
+    TRACE_EVENT0("gpu", "Warm up rand");
+    // Warm up the random subsystem, which needs to be done pre-sandbox on all
+    // platforms.
+    (void) base::RandUint64();
+  }
+  return true;
+}
+
+#if !defined(OS_MACOSX)
+bool CollectGraphicsInfo(gpu::GPUInfo& gpu_info) {
+  bool res = true;
+  gpu::CollectInfoResult result = gpu::CollectContextGraphicsInfo(&gpu_info);
+  switch (result) {
+    case gpu::kCollectInfoFatalFailure:
+      LOG(ERROR) << "gpu::CollectGraphicsInfo failed (fatal).";
+      res = false;
+      break;
+    case gpu::kCollectInfoNonFatalFailure:
+      VLOG(1) << "gpu::CollectGraphicsInfo failed (non-fatal).";
+      break;
+    case gpu::kCollectInfoSuccess:
+      break;
+  }
+  GetContentClient()->SetGpuInfo(gpu_info);
+  return res;
+}
+#endif
+
 #if defined(OS_LINUX)
+#if !defined(OS_CHROMEOS)
+bool CanAccessNvidiaDeviceFile() {
+  bool res = true;
+  base::ThreadRestrictions::AssertIOAllowed();
+  if (access("/dev/nvidiactl", R_OK) != 0) {
+    VLOG(1) << "NVIDIA device file /dev/nvidiactl access denied";
+    res = false;
+  }
+  return res;
+}
+#endif
+
 void CreateDummyGlContext() {
   scoped_refptr<gfx::GLSurface> surface(
       gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size()));
   if (!surface.get()) {
     VLOG(1) << "gfx::GLSurface::CreateOffscreenGLSurface failed";
     return;
   }
 
   // On Linux, this is needed to make sure /dev/nvidiactl has
   // been opened and its descriptor cached.
   scoped_refptr<gfx::GLContext> context(gfx::GLContext::CreateGLContext(
       NULL, surface.get(), gfx::PreferDiscreteGpu));
   if (!context.get()) {
     VLOG(1) << "gfx::GLContext::CreateGLContext failed";
     return;
   }
 
   // Similarly, this is needed for /dev/nvidia0.
   if (context->MakeCurrent(surface.get())) {
     context->ReleaseCurrent(surface.get());
   } else {
     VLOG(1)  << "gfx::GLContext::MakeCurrent failed";
   }
 }
-#endif
 
-bool WarmUpSandbox(const CommandLine& command_line) {
-  {
-    TRACE_EVENT0("gpu", "Warm up rand");
-    // Warm up the random subsystem, which needs to be done pre-sandbox on all
-    // platforms.
-    (void) base::RandUint64();
-  }
-  return true;
-}
-
-#if defined(OS_LINUX)
 void WarmUpSandboxNvidia(const gpu::GPUInfo& gpu_info,
                          bool should_initialize_gl_context) {
   // We special case Optimus since the vendor_id we see may not be Nvidia.
   bool uses_nvidia_driver = (gpu_info.gpu.vendor_id == 0x10de &&  // NVIDIA.
                              gpu_info.driver_vendor == "NVIDIA") ||
                             gpu_info.optimus;
   if (uses_nvidia_driver && should_initialize_gl_context) {
     // We need this on Nvidia to pre-open /dev/nvidiactl and /dev/nvidia0.
     CreateDummyGlContext();
   }
@@ skipping 48 matching lines @@
     return true;
   }
 
   return false;
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace.
 
 }  // namespace content