Always use glXCreateContextAttribsARB to create GLX contexts.

ui/gl/gl_surface_glx.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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
@@ skipping 433 matching lines @@
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
     return false;
   }
   size_ = gfx::Size(attributes.width, attributes.height);
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_));
   else if (g_glx_sgi_video_sync_supported)
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_));
 
+  glx_window_ = glXCreateWindow(
+      g_display,
+      static_cast<GLXFBConfig>(GetConfig()),
+      window_,
+      NULL);
+  if (!glx_window_) {
+    LOG(ERROR) << "glXCreateWindow failed for window " << window_ << ".";
+    return false;
+  }
+
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
+  if (glx_window_) {
+    glXDestroyWindow(g_display, glx_window_);
+    glx_window_ = 0;
+  }
 }
 
 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size) {
   // On Intel drivers, the frame buffer won't be resize until the next swap. If
   // we only do PostSubBuffer, then we're stuck in the old size. Force a swap
   // now.
   if (gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer && size_ != size)
     SwapBuffers();
   size_ = size;
   return true;
 }
 
 bool NativeViewGLSurfaceGLX::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceGLX::SwapBuffers() {
-  glXSwapBuffers(g_display, window_);
+  glXSwapBuffers(g_display, glx_window_);
   // For latency_tests.cc:
   UNSHIPPED_TRACE_EVENT_INSTANT0("test_gpu", "CompositorSwapBuffersComplete");
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceGLX::GetSize() {
   return size_;
 }
 
 void* NativeViewGLSurfaceGLX::GetHandle() {
-  return reinterpret_cast<void*>(window_);
+  return reinterpret_cast<void*>(glx_window_);
 }
 
 std::string NativeViewGLSurfaceGLX::GetExtensions() {
   std::string extensions = GLSurface::GetExtensions();
   if (gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer) {
     extensions += extensions.empty() ? "" : " ";
     extensions += "GL_CHROMIUM_post_sub_buffer";
   }
   return extensions;
 }
 
 void* NativeViewGLSurfaceGLX::GetConfig() {
   if (!config_) {
     // This code path is expensive, but we only take it when
     // attempting to use GLX_ARB_create_context_robustness, in which
     // case we need a GLXFBConfig for the window in order to create a
     // context for it.
     //
     // TODO(kbr): this is not a reliable code path. On platforms which
     // support it, we should use glXChooseFBConfig in the browser
     // process to choose the FBConfig and from there the X Visual to
     // use when creating the window in the first place. Then we can
     // pass that FBConfig down rather than attempting to reconstitute
     // it.
 
     XWindowAttributes attributes;
     if (!XGetWindowAttributes(
         g_display,
-        reinterpret_cast<GLXDrawable>(GetHandle()),
+        window_,
         &attributes)) {
       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
-          reinterpret_cast<GLXDrawable>(GetHandle()) << ".";
+          window_ << ".";
       return NULL;
     }
 
     int visual_id = XVisualIDFromVisual(attributes.visual);
 
     int num_elements = 0;
     scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> configs(
         glXGetFBConfigs(g_display,
                         DefaultScreen(g_display),
                         &num_elements));
@@ skipping 23 matching lines @@
       config_ = configs.get()[i];
     }
   }
 
   return config_;
 }
 
 bool NativeViewGLSurfaceGLX::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
-  glXCopySubBufferMESA(g_display, window_, x, y, width, height);
+  glXCopySubBufferMESA(g_display, glx_window_, x, y, width, height);
   return true;
 }
 
 void NativeViewGLSurfaceGLX::GetVSyncParameters(
     const UpdateVSyncCallback& callback) {
   if (vsync_provider_)
     vsync_provider_->GetVSyncParameters(callback);
 }
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
@@ skipping 88 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx