Avoid gpu watchdog crash on timeout if X is un-responsive.

content/gpu/gpu_watchdog_thread.cc

Index: content/gpu/gpu_watchdog_thread.cc
diff --git a/content/gpu/gpu_watchdog_thread.cc b/content/gpu/gpu_watchdog_thread.cc
index 02b6bff8040e8f6c7c464f309c31761da0f508f9..1462f09fc1d9a3210494a5a72ed9335f96770fd7 100644
--- a/content/gpu/gpu_watchdog_thread.cc
+++ b/content/gpu/gpu_watchdog_thread.cc
@@ -39,6 +39,12 @@ GpuWatchdogThread::GpuWatchdogThread(int timeout)
 #endif
       task_observer_(this),
       suspended_(false),
+#if defined(USE_X11)
+      x_server_active_(true),
+      display_(NULL),
+      window_(1),

[piman, 2015/02/04 01:03:05]

why 1?

[sohanjg, 2015/02/06 10:40:58]

Done.

+      atom_(None),
+#endif
       weak_factory_(this) {
   DCHECK(timeout >= 0);
 
@@ -59,6 +65,9 @@ GpuWatchdogThread::GpuWatchdogThread(int timeout)
 #if defined(OS_CHROMEOS)
   tty_file_ = base::OpenFile(base::FilePath(kTtyFilePath), "r");
 #endif
+#if defined(USE_X11)
+  SetupXServer();
+#endif
   watched_message_loop_->AddTaskObserver(&task_observer_);
 }
 
@@ -184,14 +193,25 @@ void GpuWatchdogThread::OnCheck(bool after_suspend) {
       FROM_HERE,
       base::Bind(&base::DoNothing));
 
-  // Post a task to the watchdog thread to exit if the monitored thread does
-  // not respond in time.
+#if defined(USE_X11)
+  // Post a task to the watchdog thread to check XServer is active
+  // if the monitored thread does not respond in time.
+  SetupXChangeProp();
   message_loop()->PostDelayedTask(

[sohanjg, 2015/02/02 14:17:19]

Should we post a delayed task here, or explicitly call CheckXServerActive, and
poll there till timeout ?

-      FROM_HERE,
-      base::Bind(
-          &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
-          weak_factory_.GetWeakPtr()),
+      FROM_HERE, base::Bind(&GpuWatchdogThread::CheckXServerActive,
+                            weak_factory_.GetWeakPtr()),
       timeout);
+  if (!x_server_active_)
+#endif
+  {
+    // Post a task to the watchdog thread to exit if the monitored thread does
+    // not respond in time.
+    message_loop()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
+                   weak_factory_.GetWeakPtr()),
+        timeout);
+  }
 }
 
 // Use the --disable-gpu-watchdog command line switch to disable this.
@@ -259,6 +279,37 @@ void GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang() {
   terminated = true;
 }
 
+#if defined(USE_X11)
+void GpuWatchdogThread::CheckXServerActive() {
+  unsigned long nitems = 0;
+  unsigned long nbytes = 0;
+  XAtom prop_type = None;
+  int prop_format = 0;
+  unsigned char* property_data = NULL;
+  if (XGetWindowProperty(display_, window_, atom_, 0, 65535, False,
+                         AnyPropertyType, &prop_type, &prop_format, &nitems,
+                         &nbytes, &property_data) == Success) {

[piman, 2015/02/04 01:03:05]

If X is blocked, this will block. I don't think that's what we want, is it?
I would think instead we'd want to check in
DeliberatelyTerminateToRecoverFromHang, after we think the main thread is
blocked.
Then you would want to do a non-blocking round trip to X. Maybe setting a
property, flushing, and then polling for a property change (i.e. XSelectInput
with PropertyChangeMask - prior to setting the property - and then checking for
events with XCheckWindowEvent in a poll() loop over the Display's
ConnectionNumber, with a timeout).

[sohanjg, 2015/02/06 10:40:58]

Done.

+    if (prop_type == XA_STRING && prop_format == 8 && nitems == 5) {
+      x_server_active_ = true;
+      return;
+    }
+  }
+  x_server_active_ = false;
+}
+
+void GpuWatchdogThread::SetupXServer() {
+  display_ = XOpenDisplay(NULL);
+  window_ = XCreateWindow(display_, DefaultRootWindow(display_), 0, 0, 1, 1, 0,
+                          CopyFromParent, InputOutput, CopyFromParent, 0, NULL);
+}
+
+void GpuWatchdogThread::SetupXChangeProp() {
+  unsigned char text[20] = "check";
+  atom_ = XInternAtom(display_, "CHK", False);
+  XChangeProperty(display_, window_, atom_, XA_STRING, 8, PropModeReplace, text,
+                  5);
+}
+#endif
 void GpuWatchdogThread::AddPowerObserver() {
   message_loop()->PostTask(
       FROM_HERE,