Change X11 error handler override to allow easy X11 error checking.

ui/base/x/x11_util.cc

 // Copyright (c) 2011 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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 50 matching lines @@
        FROM_HERE, NewRunnableFunction(LogErrorEventDescription, d, *e));
   return 0;
 }
 
 int DefaultX11IOErrorHandler(Display* d) {
   // If there's an IO error it likely means the X server has gone away
   LOG(ERROR) << "X IO Error detected";
   _exit(1);
 }
 
+XErrorHandler current_error_handler = DefaultX11ErrorHandler;
+XErrorEvent* last_error_event = NULL;
+
+int BaseX11ErrorHandler(Display* d, XErrorEvent* e) {
+  last_error_event = e;

[Ami GONE FROM CHROMIUM, 2011/09/14 23:23:11]

(this is the comment referenced from the .h comment)
Is there any reason to believe |e| will continue to point to valid data after
this returns?
I imagined there'd be a memcpy here into an error struct that this file owned,
and that the getter would further memcpy a copy for each caller.

+  return current_error_handler(d, e);
+}
+
 // Note: The caller should free the resulting value data.
 bool GetProperty(XID window, const std::string& property_name, long max_length,
                  Atom* type, int* format, unsigned long* num_items,
                  unsigned char** property) {
   Atom property_atom = gdk_x11_get_xatom_by_name_for_display(
       gdk_display_get_default(), property_name.c_str());
 
   unsigned long remaining_bytes = 0;
   return XGetWindowProperty(GetXDisplay(),
                             window,
@@ skipping 591 matching lines @@
   event.xclient.format = 32;
   event.xclient.data.l[0] = desktop;
   event.xclient.data.l[1] = 1;  // source indication
 
   int result = XSendEvent(GetXDisplay(), GetX11RootWindow(), False,
                           SubstructureNotifyMask, &event);
   return result == Success;
 }
 
 void SetDefaultX11ErrorHandlers() {
+  XSetErrorHandler(BaseX11ErrorHandler);
   SetX11ErrorHandlers(NULL, NULL);
 }
 
 bool IsX11WindowFullScreen(XID window) {
   // First check if _NET_WM_STATE property contains _NET_WM_STATE_FULLSCREEN.
   static Atom atom = gdk_x11_get_xatom_by_name_for_display(
       gdk_display_get_default(), "_NET_WM_STATE_FULLSCREEN");
 
   std::vector<Atom> atom_properties;
   if (GetAtomArrayProperty(window,
@@ skipping 11 matching lines @@
   gfx::Rect window_rect;
   if (!ui::GetWindowRect(window, &window_rect))
     return false;
 
   return monitor_rect.x == window_rect.x() &&
          monitor_rect.y == window_rect.y() &&
          monitor_rect.width == window_rect.width() &&
          monitor_rect.height == window_rect.height();
 }
 
+XErrorEvent* GetLastX11Error(Display* display) {
+  XSync(display, False);
+  XErrorEvent* e = last_error_event;
+  last_error_event = NULL;
+  return e;
+}
+
 // ----------------------------------------------------------------------------
 // These functions are declared in x11_util_internal.h because they require
 // XLib.h to be included, and it conflicts with many other headers.
 XRenderPictFormat* GetRenderARGB32Format(Display* dpy) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   // First look for a 32-bit format which ignores the alpha value
   XRenderPictFormat templ;
@@ skipping 58 matching lines @@
     // always blowing away the cache. If we are, then we should figure out why
     // and make it bigger.
     NOTREACHED();
   }
 
   return pictformat;
 }
 
 void SetX11ErrorHandlers(XErrorHandler error_handler,
                          XIOErrorHandler io_error_handler) {
-  XSetErrorHandler(error_handler ? error_handler : DefaultX11ErrorHandler);
-  XSetIOErrorHandler(
-      io_error_handler ? io_error_handler : DefaultX11IOErrorHandler);
+  current_error_handler = error_handler ?
+      error_handler : DefaultX11ErrorHandler;
+  XSetIOErrorHandler(io_error_handler ?
+                     io_error_handler : DefaultX11IOErrorHandler);
 }
 
 void LogErrorEventDescription(Display* dpy,
                               const XErrorEvent& error_event) {
   char error_str[256];
   char request_str[256];
 
   XGetErrorText(dpy, error_event.error_code, error_str, sizeof(error_str));
 
   strncpy(request_str, "Unknown", sizeof(request_str));
@@ skipping 29 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui