Less X connections.

ui/gfx/gl/gl_surface_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_surface_glx.h"
 
@@ skipping 13 matching lines @@
 // 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 {
     ::XFree(x);
   }
 };
 
-Display* g_display;
 const char* g_glx_extensions = NULL;
 bool g_glx_create_context_robustness_supported = false;
 
 }  // namespace anonymous
 
 GLSurfaceGLX::GLSurfaceGLX() {
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {
 }
 
 bool GLSurfaceGLX::InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
-  g_display = XOpenDisplay(NULL);
-  if (!g_display) {
+  if (!ui::GetXDisplay()) {
     LOG(ERROR) << "XOpenDisplay failed.";
     return false;
   }
 
   int major, minor;
-  if (!glXQueryVersion(g_display, &major, &minor)) {
+  if (!glXQueryVersion(ui::GetXDisplay(), &major, &minor)) {
     LOG(ERROR) << "glxQueryVersion failed";
     return false;
   }
 
   if (major == 1 && minor < 3) {
     LOG(ERROR) << "GLX 1.3 or later is required.";
     return false;
   }
 
-  g_glx_extensions = glXQueryExtensionsString(g_display, 0);
+  g_glx_extensions = glXQueryExtensionsString(ui::GetXDisplay(), 0);
   g_glx_create_context_robustness_supported =
       HasGLXExtension("GLX_ARB_create_context_robustness");
 
   initialized = true;
   return true;
 }
 
 // static
 const char* GLSurfaceGLX::GetGLXExtensions() {
   return g_glx_extensions;
@@ skipping 13 matching lines @@
 
   return extensions.find(delimited_name) != std::string::npos;
 }
 
 // static
 bool GLSurfaceGLX::IsCreateContextRobustnessSupported() {
   return g_glx_create_context_robustness_supported;
 }
 
 void* GLSurfaceGLX::GetDisplay() {
-  return g_display;
+  return ui::GetXDisplay();
 }
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::PluginWindowHandle window)
   : window_(window),
     config_(NULL) {
 }
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
   : window_(0),
     config_(NULL) {
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 bool NativeViewGLSurfaceGLX::Initialize() {
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
 }
 
 bool NativeViewGLSurfaceGLX::IsOffscreen() {
   return false;
 }
 
 bool NativeViewGLSurfaceGLX::SwapBuffers() {
-  glXSwapBuffers(g_display, window_);
+  glXSwapBuffers(ui::GetXDisplay(), window_);
   return true;
 }
 
 gfx::Size NativeViewGLSurfaceGLX::GetSize() {
   XWindowAttributes attributes;
-  if (!XGetWindowAttributes(g_display, window_, &attributes)) {
+  if (!XGetWindowAttributes(ui::GetXDisplay(), window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << window_ << ".";
     return gfx::Size();
   }
   return gfx::Size(attributes.width, attributes.height);
 }
 
 void* NativeViewGLSurfaceGLX::GetHandle() {
   return reinterpret_cast<void*>(window_);
 }
 
@@ skipping 15 matching lines @@
     //
     // 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,
+        ui::GetXDisplay(),
         reinterpret_cast<GLXDrawable>(GetHandle()),
         &attributes)) {
       LOG(ERROR) << "XGetWindowAttributes failed for window " <<
           reinterpret_cast<GLXDrawable>(GetHandle()) << ".";
       return NULL;
     }
 
     int visual_id = XVisualIDFromVisual(attributes.visual);
 
     int num_elements = 0;
     scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> configs(
-        glXGetFBConfigs(g_display,
-                        DefaultScreen(g_display),
+        glXGetFBConfigs(ui::GetXDisplay(),
+                        DefaultScreen(ui::GetXDisplay()),
                         &num_elements));
     if (!configs.get()) {
       LOG(ERROR) << "glXGetFBConfigs failed.";
       return NULL;
     }
     if (!num_elements) {
       LOG(ERROR) << "glXGetFBConfigs returned 0 elements.";
       return NULL;
     }
     bool found = false;
     int i;
     for (i = 0; i < num_elements; ++i) {
       int value;
       if (glXGetFBConfigAttrib(
-              g_display, configs.get()[i], GLX_VISUAL_ID, &value)) {
+              ui::GetXDisplay(), configs.get()[i], GLX_VISUAL_ID, &value)) {
         LOG(ERROR) << "glXGetFBConfigAttrib failed.";
         return NULL;
       }
       if (value == visual_id) {
         found = true;
         break;
       }
     }
     if (found) {
       config_ = configs.get()[i];
     }
   }
 
   return config_;
 }
 
 bool NativeViewGLSurfaceGLX::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(g_GLX_MESA_copy_sub_buffer);
-  glXCopySubBufferMESA(g_display, window_, x, y, width, height);
+  glXCopySubBufferMESA(ui::GetXDisplay(), window_, x, y, width, height);
   return true;
 }
 
 PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
   : size_(size),
     config_(NULL),
     pbuffer_(0) {
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
@@ skipping 10 matching lines @@
     GLX_GREEN_SIZE, 8,
     GLX_RED_SIZE, 8,
     GLX_RENDER_TYPE, GLX_RGBA_BIT,
     GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
     GLX_DOUBLEBUFFER, False,
     0
   };
 
   int num_elements = 0;
   scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> configs(
-      glXChooseFBConfig(g_display,
-                        DefaultScreen(g_display),
+      glXChooseFBConfig(ui::GetXDisplay(),
+                        DefaultScreen(ui::GetXDisplay()),
                         config_attributes,
                         &num_elements));
   if (!configs.get()) {
     LOG(ERROR) << "glXChooseFBConfig failed.";
     return false;
   }
   if (!num_elements) {
     LOG(ERROR) << "glXChooseFBConfig returned 0 elements.";
     return false;
   }
 
   config_ = configs.get()[0];
 
   const int pbuffer_attributes[] = {
     GLX_PBUFFER_WIDTH, size_.width(),
     GLX_PBUFFER_HEIGHT, size_.height(),
     0
   };
-  pbuffer_ = glXCreatePbuffer(g_display,
+  pbuffer_ = glXCreatePbuffer(ui::GetXDisplay(),
                               static_cast<GLXFBConfig>(config_),
                               pbuffer_attributes);
   if (!pbuffer_) {
     Destroy();
     LOG(ERROR) << "glXCreatePbuffer failed.";
     return false;
   }
 
   return true;
 }
 
 void PbufferGLSurfaceGLX::Destroy() {
   if (pbuffer_) {
-    glXDestroyPbuffer(g_display, pbuffer_);
+    glXDestroyPbuffer(ui::GetXDisplay(), pbuffer_);
     pbuffer_ = 0;
   }
 
   config_ = NULL;
 }
 
 bool PbufferGLSurfaceGLX::IsOffscreen() {
   return true;
 }
 
 bool PbufferGLSurfaceGLX::SwapBuffers() {
   NOTREACHED() << "Attempted to call SwapBuffers on a pbuffer.";
   return false;
 }
 
 gfx::Size PbufferGLSurfaceGLX::GetSize() {
   return size_;
 }
 
 void* PbufferGLSurfaceGLX::GetHandle() {
   return reinterpret_cast<void*>(pbuffer_);
 }
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 }  // namespace gfx