Don't restart the GPU process when switching to another TTY

content/gpu/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 <errno.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #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 {
-#if defined(OS_CHROMEOS)
+#if defined(USE_X11)
 const base::FilePath::CharType
     kTtyFilePath[] = FILE_PATH_LITERAL("/sys/class/tty/tty0/active");
-#endif
-#if defined(USE_X11)
 const unsigned char text[20] = "check";
 #endif
 }  // namespace
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
       watched_message_loop_(base::MessageLoop::current()),
       timeout_(base::TimeDelta::FromMilliseconds(timeout)),
       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);
   DCHECK(result);
 #endif
 
-#if defined(OS_CHROMEOS)
+#if defined(USE_X11)
   tty_file_ = base::OpenFile(base::FilePath(kTtyFilePath), "r");
-#endif
-#if defined(USE_X11)
   SetupXServer();
 #endif
   watched_message_loop_->AddTaskObserver(&task_observer_);
 }
 
 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));
@@ skipping 39 matching lines @@
   DCHECK(!weak_factory_.HasWeakPtrs());
 
 #if defined(OS_WIN)
   CloseHandle(watched_thread_handle_);
 #endif
 
   base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
   if (power_monitor)
     power_monitor->RemoveObserver(this);
 
-#if defined(OS_CHROMEOS)
+#if defined(USE_X11)
   if (tty_file_)
     fclose(tty_file_);
-#endif
-
-#if defined(USE_X11)
   XDestroyWindow(display_, window_);
   XCloseDisplay(display_);
 #endif
 
   watched_message_loop_->RemoveTaskObserver(&task_observer_);
 }
 
 void GpuWatchdogThread::OnAcknowledge() {
   CHECK(base::PlatformThread::CurrentId() == GetThreadId());
 
@@ skipping 163 matching lines @@
   // useful.
   static bool terminated = false;
   if (terminated)
     return;
 
 #if defined(OS_WIN)
   if (IsDebuggerPresent())
     return;
 #endif
 
-#if defined(OS_CHROMEOS)
-  // Don't crash if we're not on tty1. This avoids noise in the GPU process
-  // crashes caused by people who use VT2 but still enable crash reporting.
-  char tty_string[8] = {0};
-  if (tty_file_ &&
-      !fseek(tty_file_, 0, SEEK_SET) &&
-      fread(tty_string, 1, 7, tty_file_)) {
-    int tty_number = -1;
-    int num_res = sscanf(tty_string, "tty%d", &tty_number);
-    if (num_res == 1 && tty_number != 1)
-      return;
+#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) {
+    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);
 
   // This is the time since the watchdog was armed, in 100ns intervals,
@@ skipping 24 matching lines @@
 
   terminated = true;
 }
 
 #if defined(USE_X11)
 void GpuWatchdogThread::SetupXServer() {
   display_ = XOpenDisplay(NULL);
   window_ = XCreateWindow(display_, DefaultRootWindow(display_), 0, 0, 1, 1, 0,
                           CopyFromParent, InputOutput, CopyFromParent, 0, NULL);
   atom_ = XInternAtom(display_, "CHECK", False);
+  host_tty_ = GetActiveTTY();
 }
 
 void GpuWatchdogThread::SetupXChangeProp() {
   XChangeProperty(display_, window_, atom_, XA_STRING, 8, PropModeReplace, text,
                   (arraysize(text) - 1));
 }
 
 bool GpuWatchdogThread::MatchXEventAtom(XEvent* event) {
   if (event->xproperty.window == window_ && event->type == PropertyNotify &&
       event->xproperty.atom == atom_)
@@ skipping 63 matching lines @@
     // returns to user level or where user level code
     // calls into kernel level repeatedly, giving up its quanta before it is
     // tracked, for example a loop that repeatedly Sleeps.
     return base::ThreadTicks() +
            base::TimeDelta::FromMilliseconds(static_cast<int64_t>(
                (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
   }
 }
 #endif
 
+#if defined(USE_X11)
+int GpuWatchdogThread::GetActiveTTY() const {
+  char tty_string[8] = {0};
+  if (tty_file_ && !fseek(tty_file_, 0, SEEK_SET) &&
+      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