gpu: Move GpuWatchdogThread into //gpu/ipc/service from content.

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 <stddef.h>
 #include <stdlib.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/gpu_host_messages.h"
 #include "content/common/sandbox_linux/sandbox_linux.h"
 #include "content/gpu/gpu_child_thread.h"
 #include "content/gpu/gpu_process.h"
-#include "content/gpu/gpu_watchdog_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "gpu/config/gpu_switches.h"
 #include "gpu/config/gpu_util.h"
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
 #include "gpu/ipc/service/gpu_config.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
+#include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/gpu_switching_manager.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 29 matching lines @@
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
 #include "media/gpu/vaapi_wrapper.h"
 #endif
 
 #if defined(SANITIZER_COVERAGE)
 #include <sanitizer/common_interface_defs.h>
 #include <sanitizer/coverage_interface.h>
 #endif
 
-#if defined(CYGPROFILE_INSTRUMENTATION)
-const int kGpuTimeout = 30000;
-#elif defined(OS_WIN)
-// Use a slightly longer timeout on Windows due to prevalence of slow and
-// infected machines.
-const int kGpuTimeout = 15000;
-#else
-const int kGpuTimeout = 10000;
-#endif
-
 namespace content {
 
 namespace {
 
 void GetGpuInfoFromCommandLine(gpu::GPUInfo& gpu_info,
                                const base::CommandLine& command_line);
 void WarmUpSandbox();
 
 #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 StartSandboxLinux(const gpu::GPUInfo&, gpu::GpuWatchdogThread*);
 #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,
                                  size_t message_start,
@@ skipping 102 matching lines @@
 #endif
 
   bool delayed_watchdog_enable = false;
 
 #if defined(OS_CHROMEOS)
   // Don't start watchdog immediately, to allow developers to switch to VT2 on
   // startup.
   delayed_watchdog_enable = true;
 #endif
 
-  scoped_refptr<GpuWatchdogThread> watchdog_thread;
+  scoped_refptr<gpu::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);
-    base::Thread::Options options;
-    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
-    watchdog_thread->StartWithOptions(options);
-  }
+  if (enable_watchdog && !delayed_watchdog_enable)
+    watchdog_thread = gpu::GpuWatchdogThread::Create();
 
   // Initializes StatisticsRecorder which tracks UMA histograms.
   base::StatisticsRecorder::Initialize();
 
   gpu::GPUInfo gpu_info;
   // Get vendor_id, device_id, driver_version from browser process through
   // commandline switches.
   GetGpuInfoFromCommandLine(gpu_info, command_line);
   gpu_info.in_process_gpu = false;
 
@@ skipping 81 matching lines @@
     UMA_HISTOGRAM_TIMES("GPU.CollectContextGraphicsInfo", collect_context_time);
   } else {  // gl_initialized
     VLOG(1) << "gl::init::InitializeGLOneOff failed";
     dead_on_arrival = true;
   }
 
   base::TimeDelta initialize_one_off_time =
       base::TimeTicks::Now() - before_initialize_one_off;
   UMA_HISTOGRAM_MEDIUM_TIMES("GPU.InitializeOneOffMediumTime",
                              initialize_one_off_time);
-
-  if (enable_watchdog && delayed_watchdog_enable) {
-    watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
-    base::Thread::Options options;
-    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
-    watchdog_thread->StartWithOptions(options);
-  }
+  if (enable_watchdog && delayed_watchdog_enable)
+    watchdog_thread = gpu::GpuWatchdogThread::Create();
 
   // OSMesa is expected to run very slowly, so disable the watchdog in that
   // case.
   if (enable_watchdog &&
       gl::GetGLImplementation() == gl::kGLImplementationOSMesaGL) {
     watchdog_thread->Stop();
     watchdog_thread = NULL;
   }
 
 #if defined(OS_LINUX)
@@ skipping 146 matching lines @@
   base::ThreadRestrictions::AssertIOAllowed();
   if (access("/dev/nvidiactl", R_OK) != 0) {
     DVLOG(1) << "NVIDIA device file /dev/nvidiactl access denied";
     res = false;
   }
   return res;
 }
 #endif
 
 bool StartSandboxLinux(const gpu::GPUInfo& gpu_info,
-                       GpuWatchdogThread* watchdog_thread) {
+                       gpu::GpuWatchdogThread* watchdog_thread) {
   TRACE_EVENT0("gpu,startup", "Initialize sandbox");
 
   bool res = false;
 
   if (watchdog_thread) {
     // LinuxSandbox needs to be able to ensure that the thread
     // has really been stopped.
     LinuxSandbox::StopThread(watchdog_thread);
   }
 
@@ skipping 33 matching lines @@
     return true;
   }
 
   return false;
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace.
 
 }  // namespace content