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

ui/gfx/gl/gl_context_glx.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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gfx/gl/gl_context_glx.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/mesa/MesaLib/include/GL/osmesa.h"
+#include "ui/base/x/x11_util.h"
+#include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_glx.h"
 
+#define CHECK_X_ERROR() do { \
+    CHECK(!ui::GetLastX11Error(gfx::GLSurfaceGLX::GetDisplay())); \
+  } while(0)
+
 namespace gfx {
 
 namespace {
 
 // scoped_ptr functor for XFree(). Use as follows:
 //   scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> foo(...);
 // where "XVisualInfo" is any X type that is freed with XFree.
 class ScopedPtrXFree {
  public:
   void operator()(void* x) const {
@@ skipping 53 matching lines @@
       // in this case, since we will likely allocate our offscreen
       // contexts with this bit set and the onscreen contexts without,
       // and won't be able to put them in the same share group.
       // Consider what to do here; force loss of all contexts and
       // reallocation without ARB_robustness?
       LOG(ERROR) <<
           "  FAILED to allocate GL context with LOSE_CONTEXT_ON_RESET_ARB";
     }
   }
 
+  CHECK_X_ERROR();
+
   if (!context_) {
     // The means by which the context is created depends on whether
     // the drawable type works reliably with GLX 1.3. If it does not
     // then fall back to GLX 1.2.
     if (surface_glx->IsOffscreen()) {
       context_ = glXCreateNewContext(
           GLSurfaceGLX::GetDisplay(),
           static_cast<GLXFBConfig>(surface_glx->GetConfig()),
           GLX_RGBA_TYPE,
           share_handle,
           True);
     } else {
       Display* display = GLSurfaceGLX::GetDisplay();
 
       // Get the visuals for the X drawable.
       XWindowAttributes attributes;
       if (!XGetWindowAttributes(
           display,
           reinterpret_cast<GLXDrawable>(surface_glx->GetHandle()),
           &attributes)) {
         LOG(ERROR) << "XGetWindowAttributes failed for window " <<
             reinterpret_cast<GLXDrawable>(surface_glx->GetHandle()) << ".";
         return false;
       }
 
+      CHECK_X_ERROR();
+
       XVisualInfo visual_info_template;
       visual_info_template.visualid = XVisualIDFromVisual(attributes.visual);
 
       int visual_info_count = 0;
       scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> visual_info_list(
           XGetVisualInfo(display, VisualIDMask,
                          &visual_info_template,
                          &visual_info_count));
 
       DCHECK(visual_info_list.get());
       if (visual_info_count == 0) {
         LOG(ERROR) << "No visual info for visual ID.";
         return false;
       }
 
       // Attempt to create a context with each visual in turn until one works.
       context_ = glXCreateContext(
           display,
           visual_info_list.get(),
           share_handle,
           True);
     }
   }
+  CHECK_X_ERROR();
 
   if (!context_) {
     LOG(ERROR) << "Couldn't create GL context.";
     Destroy();
     return false;
   }
 
   DLOG(INFO) << (surface_glx->IsOffscreen() ? "Offscreen" : "Onscreen")
              << " context was "
              << (glXIsDirect(GLSurfaceGLX::GetDisplay(),
@@ skipping 95 matching lines @@
   }
 
   return GLContext::GetExtensions();
 }
 
 bool GLContextGLX::WasAllocatedUsingARBRobustness() {
   return GLSurfaceGLX::IsCreateContextRobustnessSupported();
 }
 
 }  // namespace gfx