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

gpu/ipc/service/gpu_watchdog_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_watchdog_thread.h"
+#include "gpu/ipc/service/gpu_watchdog_thread.h"
 
 #include <errno.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
-#include "content/public/common/content_switches.h"
-#include "content/public/common/result_codes.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
-namespace content {
+namespace gpu {
 namespace {
+
+#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
+
 #if defined(USE_X11)
-const base::FilePath::CharType
-    kTtyFilePath[] = FILE_PATH_LITERAL("/sys/class/tty/tty0/active");
+const base::FilePath::CharType kTtyFilePath[] =
+    FILE_PATH_LITERAL("/sys/class/tty/tty0/active");
 const unsigned char text[20] = "check";
 #endif
+
 }  // namespace
 
-GpuWatchdogThread::GpuWatchdogThread(int timeout)
+GpuWatchdogThread::GpuWatchdogThread()
     : base::Thread("Watchdog"),
       watched_message_loop_(base::MessageLoop::current()),
-      timeout_(base::TimeDelta::FromMilliseconds(timeout)),
+      timeout_(base::TimeDelta::FromMilliseconds(kGpuTimeout)),
       armed_(false),
       task_observer_(this),
       use_thread_cpu_time_(true),
       responsive_acknowledge_count_(0),
 #if defined(OS_WIN)
       watched_thread_handle_(0),
       arm_cpu_time_(),
 #endif
       suspended_(false),
 #if defined(USE_X11)
       display_(NULL),
       window_(0),
       atom_(None),
       host_tty_(-1),
 #endif
       weak_factory_(this) {
-  DCHECK(timeout >= 0);
-
 #if defined(OS_WIN)
   // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
   // to identify another. DuplicateHandle creates a "real" handle that can be
   // used for this purpose.
-  BOOL result = DuplicateHandle(GetCurrentProcess(),
-                                GetCurrentThread(),
-                                GetCurrentProcess(),
-                                &watched_thread_handle_,
-                                THREAD_QUERY_INFORMATION,
-                                FALSE,
-                                0);
+  BOOL result = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
+                                GetCurrentProcess(), &watched_thread_handle_,
+                                THREAD_QUERY_INFORMATION, FALSE, 0);
   DCHECK(result);
 #endif
 
 #if defined(USE_X11)
   tty_file_ = base::OpenFile(base::FilePath(kTtyFilePath), "r");
   SetupXServer();
 #endif
   watched_message_loop_->AddTaskObserver(&task_observer_);
 }
 
+// static
+scoped_refptr<GpuWatchdogThread> GpuWatchdogThread::Create() {
+  scoped_refptr<GpuWatchdogThread> watchdog_thread = new GpuWatchdogThread();
+  base::Thread::Options options;
+  options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+  watchdog_thread->StartWithOptions(options);
+  return watchdog_thread;
+}
+
 void GpuWatchdogThread::PostAcknowledge() {
   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
   // the method factory. Rely on reference counting instead.
   task_runner()->PostTask(FROM_HERE,
                           base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
 }
 
 void GpuWatchdogThread::CheckArmed() {
   // Acknowledge the watchdog if it has armed itself. The watchdog will not
   // change its armed state until it is acknowledged.
   if (armed()) {
     PostAcknowledge();
   }
 }
 
 void GpuWatchdogThread::Init() {
   // Schedule the first check.
   OnCheck(false);
 }
 
 void GpuWatchdogThread::CleanUp() {
   weak_factory_.InvalidateWeakPtrs();
 }
 
 GpuWatchdogThread::GpuWatchdogTaskObserver::GpuWatchdogTaskObserver(
     GpuWatchdogThread* watchdog)
-    : watchdog_(watchdog) {
-}
+    : watchdog_(watchdog) {}
 
-GpuWatchdogThread::GpuWatchdogTaskObserver::~GpuWatchdogTaskObserver() {
-}
+GpuWatchdogThread::GpuWatchdogTaskObserver::~GpuWatchdogTaskObserver() {}
 
 void GpuWatchdogThread::GpuWatchdogTaskObserver::WillProcessTask(
     const base::PendingTask& pending_task) {
   watchdog_->CheckArmed();
 }
 
 void GpuWatchdogThread::GpuWatchdogTaskObserver::DidProcessTask(
-    const base::PendingTask& pending_task) {
-}
+    const base::PendingTask& pending_task) {}
 
 GpuWatchdogThread::~GpuWatchdogThread() {
   // Verify that the thread was explicitly stopped. If the thread is stopped
   // implicitly by the destructor, CleanUp() will not be called.
   DCHECK(!weak_factory_.HasWeakPtrs());
 
 #if defined(OS_WIN)
   CloseHandle(watched_thread_handle_);
 #endif
 
@@ skipping 182 matching lines @@
     return;
 
 #if defined(OS_WIN)
   if (IsDebuggerPresent())
     return;
 #endif
 
 #if defined(USE_X11)
   // Don't crash if we're not on the TTY of our host X11 server.
   int active_tty = GetActiveTTY();
-  if(host_tty_ != -1 && active_tty != -1 && host_tty_ != active_tty) {
+  if (host_tty_ != -1 && active_tty != -1 && host_tty_ != active_tty) {
     return;
   }
 #endif
 
 // Store variables so they're available in crash dumps to help determine the
 // cause of any hang.
 #if defined(OS_WIN)
   ULONGLONG fire_interrupt_time;
   QueryUnbiasedInterruptTime(&fire_interrupt_time);
 
@@ skipping 127 matching lines @@
       fread(tty_string, 1, 7, tty_file_)) {
     int tty_number;
     size_t num_res = sscanf(tty_string, "tty%d\n", &tty_number);
     if (num_res == 1)
       return tty_number;
   }
   return -1;
 }
 #endif
 
-}  // namespace content
+}  // namespace gpu