Add a new driver bug workaround SANDBOX_START_EARLY

gpu/ipc/service/gpu_init.cc

 // Copyright 2016 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 "gpu/ipc/service/gpu_init.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/sys_info.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_driver_bug_list.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "gpu/config/gpu_switches.h"
 #include "gpu/config/gpu_util.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "gpu/ipc/service/switches.h"
@@ skipping 133 matching lines @@
   GetGpuInfoFromCommandLine(gpu_info_, command_line);
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   if (gpu_info_.gpu.vendor_id == 0x10de &&  // NVIDIA
       gpu_info_.driver_vendor == "NVIDIA" && !CanAccessNvidiaDeviceFile())
     return false;
 #endif
   gpu_info_.in_process_gpu = false;
 
   sandbox_helper_->PreSandboxStartup();
 
+  std::string os_version;
+
 #if defined(OS_LINUX)
   // On Chrome OS ARM Mali, GPU driver userspace creates threads when
   // initializing a GL context, so start the sandbox early.
-  if (command_line.HasSwitch(switches::kGpuSandboxStartEarly))
+  if (command_line.HasSwitch(switches::kGpuSandboxStartEarly)) {
+    os_version = base::SysInfo::OperatingSystemVersion();
     gpu_info_.sandboxed =
         sandbox_helper_->EnsureSandboxInitialized(watchdog_thread_.get());
+  }
 #endif  // defined(OS_LINUX)
 
   base::TimeTicks before_initialize_one_off = base::TimeTicks::Now();
 
   // Load and initialize the GL implementation and locate the GL entry points if
   // needed. This initialization may have already happened if running in the
   // browser process, for example.
   bool gl_initialized = gl::GetGLImplementation() != gl::kGLImplementationNone;
   if (!gl_initialized)
     gl_initialized = gl::init::InitializeGLOneOff();
@@ skipping 18 matching lines @@
   // Recompute gpu driver bug workarounds.
   // This is necessary on systems where vendor_id/device_id aren't available
   // (Chrome OS, Android) or where workarounds may be dependent on GL_VENDOR
   // and GL_RENDERER strings which are lazily computed (Linux).
   if (!command_line.HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
     // TODO: this can not affect disabled extensions, since they're already
     // initialized in the bindings. This should be moved before bindings
     // initialization. However, populating GPUInfo fully works only on Android.
     // Other platforms would need the bindings to query GL strings.
     gpu::ApplyGpuDriverBugWorkarounds(
-        gpu_info_, const_cast<base::CommandLine*>(&command_line));
+        gpu_info_, os_version, const_cast<base::CommandLine*>(&command_line));
   }
 #endif  // !defined(OS_MACOSX)
 
   base::TimeDelta collect_context_time =
       base::TimeTicks::Now() - before_collect_context_graphics_info;
   UMA_HISTOGRAM_TIMES("GPU.CollectContextGraphicsInfo", collect_context_time);
 
   base::TimeDelta initialize_one_off_time =
       base::TimeTicks::Now() - before_initialize_one_off;
   UMA_HISTOGRAM_MEDIUM_TIMES("GPU.InitializeOneOffMediumTime",
                              initialize_one_off_time);
 
   // OSMesa is expected to run very slowly, so disable the watchdog in that
   // case.
   if (gl::GetGLImplementation() == gl::kGLImplementationOSMesaGL) {
     if (watchdog_thread_)
       watchdog_thread_->Stop();
     watchdog_thread_ = nullptr;
   } else if (enable_watchdog && delayed_watchdog_enable) {
     watchdog_thread_ = gpu::GpuWatchdogThread::Create();
   }
 
   if (!gpu_info_.sandboxed)
     gpu_info_.sandboxed =
         sandbox_helper_->EnsureSandboxInitialized(watchdog_thread_.get());
   return true;
 }
 
 }  // namespace gpu