Implicitly detect the use of --in-process-webgl by the absence of a...

app/gfx/gl/gl_context_linux.cc

 // Copyright (c) 2010 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 implements the ViewGLContext and PbufferGLContext classes.
 
 #include "app/gfx/gl/gl_context.h"
 
+extern "C" {
+#include <X11/Xlib.h>
+}
+
 #include <GL/osmesa.h>
 
 #include "app/gfx/gl/gl_bindings.h"
 #include "app/gfx/gl/gl_context_egl.h"
 #include "app/gfx/gl/gl_context_osmesa.h"
 #include "app/gfx/gl/gl_context_stub.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "app/x11_util.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 
+namespace {
+
+Display* GetXDisplayHelper() {
+  static Display* display = NULL;

[greggman, 2010/12/21 22:47:01]

I'll assume this works with multiple display, as in this will never change once
queried.

[Ken Russell (switch to Gerrit), 2010/12/21 22:49:59]

Not sure. It'll work as well as x11_util::GetXDisplay() since that uses a static
variable too.

+
+  if (!display) {
+    if (x11_util::XDisplayExists()) {
+      display = x11_util::GetXDisplay();
+    } else {
+      display = XOpenDisplay(NULL);
+    }
+  }
+  return display;
+}
+
+}
+
 namespace gfx {
 
 typedef GLXContext GLContextHandle;
 typedef GLXPbuffer PbufferHandle;
 
 class BaseLinuxGLContext : public GLContext {
  public:
   virtual std::string GetExtensions();
 };
 
@@ skipping 145 matching lines @@
            kAllowedGLImplementations,
            kAllowedGLImplementations + arraysize(kAllowedGLImplementations))) {
     LOG(ERROR) << "InitializeBestGLBindings failed.";
     return false;
   }
 
   switch (GetGLImplementation()) {
     case kGLImplementationDesktopGL: {
       // Only check the GLX version if we are in fact using GLX. We might
       // actually be using the mock GL implementation.
-      Display* display = x11_util::GetXDisplay();
+      Display* display = GetXDisplayHelper();
       int major, minor;
       if (!glXQueryVersion(display, &major, &minor)) {
         LOG(ERROR) << "glxQueryVersion failed";
         return false;
       }
 
       if (major == 1 && minor < 3) {
         LOG(WARNING) << "GLX 1.3 or later is recommended.";
       }
 
       break;
     }
     case kGLImplementationEGLGLES2:
       if (!BaseEGLContext::InitializeOneOff()) {
         LOG(ERROR) << "BaseEGLContext::InitializeOneOff failed.";
         return false;
       }
       break;
     default:
       break;
   }
 
   initialized = true;
   return true;
 }
 
 std::string BaseLinuxGLContext::GetExtensions() {
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   const char* extensions = glXQueryExtensionsString(display, 0);
   if (extensions) {
     return GLContext::GetExtensions() + " " + extensions;
   }
 
   return GLContext::GetExtensions();
 }
 
 bool ViewGLContext::Initialize(bool multisampled) {
   if (multisampled) {
     LOG(WARNING) << "Multisampling not implemented.";
   }
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   XWindowAttributes attributes;
   XGetWindowAttributes(display, window_, &attributes);
   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());
@@ skipping 18 matching lines @@
   if (!InitializeCommon()) {
     LOG(ERROR) << "GLContext::InitlializeCommon failed.";
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void ViewGLContext::Destroy() {
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   bool result = glXMakeCurrent(display, 0, 0);
 
   // glXMakeCurrent isn't supposed to fail when unsetting the context, unless
   // we have pending draws on an invalid window - which shouldn't be the case
   // here.
   DCHECK(result);
   if (context_) {
     glXDestroyContext(display, context_);
     context_ = NULL;
   }
 }
 
 bool ViewGLContext::MakeCurrent() {
   if (IsCurrent()) {
     return true;
   }
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   if (glXMakeCurrent(display, window_, context_) != True) {
     glXDestroyContext(display, context_);
     context_ = 0;
     LOG(ERROR) << "Couldn't make context current.";
     return false;
   }
 
   return true;
 }
 
 bool ViewGLContext::IsCurrent() {
   return glXGetCurrentDrawable() == window_ &&
       glXGetCurrentContext() == context_;
 }
 
 bool ViewGLContext::IsOffscreen() {
   return false;
 }
 
 bool ViewGLContext::SwapBuffers() {
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   glXSwapBuffers(display, window_);
   return true;
 }
 
 gfx::Size ViewGLContext::GetSize() {
   XWindowAttributes attributes;
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   XGetWindowAttributes(display, window_, &attributes);
   return gfx::Size(attributes.width, attributes.height);
 }
 
 void* ViewGLContext::GetHandle() {
   return context_;
 }
 
 void ViewGLContext::SetSwapInterval(int interval) {
   DCHECK(IsCurrent());
   if (HasExtension("GLX_EXT_swap_control") && glXSwapIntervalEXT) {
-    Display* display = x11_util::GetXDisplay();
+    Display* display = GetXDisplayHelper();
     glXSwapIntervalEXT(display, window_, interval);
   }
 }
 
 bool OSMesaViewGLContext::Initialize() {
   if (!osmesa_context_.Initialize(OSMESA_BGRA, NULL)) {
     LOG(ERROR) << "OSMesaGLContext::Initialize failed.";
     Destroy();
     return false;
   }
 
-  window_graphics_context_ = XCreateGC(x11_util::GetXDisplay(),
+  window_graphics_context_ = XCreateGC(GetXDisplayHelper(),
                                        window_,
                                        0,
                                        NULL);
   if (!window_graphics_context_) {
     LOG(ERROR) << "XCreateGC failed.";
     Destroy();
     return false;
   }
 
   UpdateSize();
 
   return true;
 }
 
 void OSMesaViewGLContext::Destroy() {
   osmesa_context_.Destroy();
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
 
   if (pixmap_graphics_context_) {
     XFreeGC(display, pixmap_graphics_context_);
     pixmap_graphics_context_ = NULL;
   }
 
   if (pixmap_) {
     XFreePixmap(display, pixmap_);
     pixmap_ = 0;
   }
@@ skipping 23 matching lines @@
 bool OSMesaViewGLContext::SwapBuffers() {
   // Update the size before blitting so that the blit size is exactly the same
   // as the window.
   if (!UpdateSize()) {
     LOG(ERROR) << "Failed to update size of OSMesaGLContext.";
     return false;
   }
 
   gfx::Size size = osmesa_context_.GetSize();
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
 
   // Copy the frame into the pixmap.
   XWindowAttributes attributes;
   XGetWindowAttributes(display, window_, &attributes);
   x11_util::PutARGBImage(display,
                          attributes.visual,
                          attributes.depth,
                          pixmap_,
                          pixmap_graphics_context_,
                          static_cast<const uint8*>(osmesa_context_.buffer()),
@@ skipping 22 matching lines @@
 
 void OSMesaViewGLContext::SetSwapInterval(int interval) {
   DCHECK(IsCurrent());
   // Fail silently. It is legitimate to set the swap interval on a view context
   // but XLib does not have those semantics.
 }
 
 bool OSMesaViewGLContext::UpdateSize() {
   // Get the window size.
   XWindowAttributes attributes;
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   XGetWindowAttributes(display, window_, &attributes);
   gfx::Size window_size = gfx::Size(std::max(1, attributes.width),
                                     std::max(1, attributes.height));
 
   // Early out if the size has not changed.
   gfx::Size osmesa_size = osmesa_context_.GetSize();
   if (pixmap_graphics_context_ && pixmap_ && window_size == osmesa_size)
     return true;
 
   // Change osmesa surface size to that of window.
@@ skipping 69 matching lines @@
   static const int config_attributes[] = {
     GLX_DRAWABLE_TYPE,
     GLX_PBUFFER_BIT,
     GLX_RENDER_TYPE,
     GLX_RGBA_BIT,
     GLX_DOUBLEBUFFER,
     0,
     0
   };
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
 
   int nelements = 0;
   // TODO(kbr): figure out whether hardcoding screen to 0 is sufficient.
   scoped_ptr_malloc<GLXFBConfig, ScopedPtrXFree> config(
       glXChooseFBConfig(display, 0, config_attributes, &nelements));
   if (!config.get()) {
     LOG(ERROR) << "glXChooseFBConfig failed.";
     return false;
   }
   if (!nelements) {
@@ skipping 38 matching lines @@
   if (!InitializeCommon()) {
     LOG(ERROR) << "GLContext::InitializeCommon failed.";
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void PbufferGLContext::Destroy() {
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   bool result = glXMakeCurrent(display, 0, 0);
   // glXMakeCurrent isn't supposed to fail when unsetting the context, unless
   // we have pending draws on an invalid window - which shouldn't be the case
   // here.
   DCHECK(result);
   if (context_) {
     glXDestroyContext(display, context_);
     context_ = NULL;
   }
 
   if (pbuffer_) {
     glXDestroyPbuffer(display, pbuffer_);
     pbuffer_ = 0;
   }
 }
 
 bool PbufferGLContext::MakeCurrent() {
   if (IsCurrent()) {
     return true;
   }
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   if (glXMakeCurrent(display, pbuffer_, context_) != True) {
     glXDestroyContext(display, context_);
     context_ = NULL;
     LOG(ERROR) << "Couldn't make context current.";
     return false;
   }
 
   return true;
 }
 
@@ skipping 26 matching lines @@
 }
 
 bool PixmapGLContext::Initialize(GLContext* shared_context) {
   VLOG(1) << "GL context: using pixmaps.";
 
   static int attributes[] = {
     GLX_RGBA,
     0
   };
 
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   int screen = DefaultScreen(display);
 
   scoped_ptr_malloc<XVisualInfo, ScopedPtrXFree> visual_info(
       glXChooseVisual(display, screen, attributes));
 
   if (!visual_info.get()) {
     LOG(ERROR) << "glXChooseVisual failed.";
     return false;
   }
 
@@ skipping 29 matching lines @@
   if (!InitializeCommon()) {
     LOG(ERROR) << "GLContext::InitializeCommon failed.";
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void PixmapGLContext::Destroy() {
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   bool result = glXMakeCurrent(display, 0, 0);
   // glXMakeCurrent isn't supposed to fail when unsetting the context, unless
   // we have pending draws on an invalid window - which shouldn't be the case
   // here.
   DCHECK(result);
   if (context_) {
     glXDestroyContext(display, context_);
     context_ = NULL;
   }
 
   if (glx_pixmap_) {
     glXDestroyGLXPixmap(display, glx_pixmap_);
     glx_pixmap_ = 0;
   }
 
   if (pixmap_) {
     XFreePixmap(display, pixmap_);
     pixmap_ = 0;
   }
 }
 
 bool PixmapGLContext::MakeCurrent() {
   if (IsCurrent()) {
     return true;
   }
-  Display* display = x11_util::GetXDisplay();
+  Display* display = GetXDisplayHelper();
   if (glXMakeCurrent(display, glx_pixmap_, context_) != True) {
     glXDestroyContext(display, context_);
     context_ = NULL;
     LOG(ERROR) << "Couldn't make context current.";
     return false;
   }
 
   return true;
 }
 
@@ skipping 55 matching lines @@
     }
     case kGLImplementationMockGL:
       return new StubGLContext;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace gfx