Allow maximum timer coalescing of the GPU watchdog thread.

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 188 matching lines @@
   // startup.
   delayed_watchdog_enable = true;
 #endif
 
   scoped_refptr<GpuWatchdogThread> watchdog_thread;
 
   // 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();
+    base::Thread::Options options;
+    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+    watchdog_thread->StartWithOptions(options);
   }
 
   gpu::GPUInfo gpu_info;
   // Get vendor_id, device_id, driver_version from browser process through
   // commandline switches.
   GetGpuInfoFromCommandLine(gpu_info, command_line);
 
   base::TimeDelta collect_context_time;
   base::TimeDelta initialize_one_off_time;
 
@@ skipping 73 matching lines @@
     } 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();
+      base::Thread::Options options;
+      options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+      watchdog_thread->StartWithOptions(options);
     }
 
     // OSMesa is expected to run very slowly, so disable the watchdog in that
     // case.
     if (enable_watchdog &&
         gfx::GetGLImplementation() == gfx::kGLImplementationOSMesaGL) {
       watchdog_thread->Stop();
       watchdog_thread = NULL;
     }
 
@@ skipping 174 matching lines @@
   linux_sandbox->sanitizer_args()->coverage_sandboxed = 1;
   linux_sandbox->sanitizer_args()->coverage_fd =
       __sanitizer_maybe_open_cov_file(sancov_file_name.c_str());
   linux_sandbox->sanitizer_args()->coverage_max_block_size = 0;
 #endif
 
   // LinuxSandbox::InitializeSandbox() must always be called
   // with only one thread.
   res = LinuxSandbox::InitializeSandbox();
   if (watchdog_thread) {
-    watchdog_thread->Start();
+    base::Thread::Options options;
+    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+    watchdog_thread->StartWithOptions(options);
   }
 
   return res;
 }
 #endif  // defined(OS_LINUX)
 
 #if defined(OS_WIN)
 bool StartSandboxWindows(const sandbox::SandboxInterfaceInfo* sandbox_info) {
   TRACE_EVENT0("gpu", "Lower token");
 
   // For Windows, if the target_services interface is not zero, the process
   // is sandboxed and we must call LowerToken() before rendering untrusted
   // content.
   sandbox::TargetServices* target_services = sandbox_info->target_services;
   if (target_services) {
     target_services->LowerToken();
     return true;
   }
 
   return false;
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace.
 
 }  // namespace content