Added EGL based GLContext....

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 <dlfcn.h>
-#include <GL/glew.h>
-#include <GL/glxew.h>
-#include <GL/glx.h>
-#include <GL/osmew.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-
 #include "app/x11_util.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
+#include "app/gfx/gl/gl_bindings.h"
 #include "app/gfx/gl/gl_context.h"
 #include "app/gfx/gl/gl_context_osmesa.h"
+#include "app/gfx/gl/gl_context_stub.h"
+#include "app/gfx/gl/gl_implementation.h"
 
 namespace gfx {
 
 typedef GLXContext GLContextHandle;
 typedef GLXPbuffer PbufferHandle;
 
 // This class is a wrapper around a GL context that renders directly to a
 // window.
 class ViewGLContext : public GLContext {
  public:
@@ skipping 25 matching lines @@
 // It is initially backed by a 1x1 pbuffer. Use it to create an FBO to do useful
 // rendering.
 class PbufferGLContext : public GLContext {
  public:
   explicit PbufferGLContext()
       : context_(NULL),
         pbuffer_(0) {
   }
 
   // Initializes the GL context.
-  bool Initialize(void* shared_handle);
+  bool Initialize(GLContext* shared_context);
 
   virtual void Destroy();
   virtual bool MakeCurrent();
   virtual bool IsCurrent();
   virtual bool IsOffscreen();
   virtual void SwapBuffers();
   virtual gfx::Size GetSize();
   virtual void* GetHandle();
 
  private:
   GLContextHandle context_;
   PbufferHandle pbuffer_;
 
   DISALLOW_COPY_AND_ASSIGN(PbufferGLContext);
 };
 
 // Backup context if Pbuffers (GLX 1.3) aren't supported. May run slower...
 class PixmapGLContext : public GLContext {
  public:
   explicit PixmapGLContext()
       : context_(NULL),
         pixmap_(0),
         glx_pixmap_(0) {
   }
 
   // Initializes the GL context.
-  bool Initialize(void* shared_handle);
+  bool Initialize(GLContext* shared_context);
 
   virtual void Destroy();
   virtual bool MakeCurrent();
   virtual bool IsCurrent();
   virtual bool IsOffscreen();
   virtual void SwapBuffers();
   virtual gfx::Size GetSize();
   virtual void* GetHandle();
 
  private:
   GLContextHandle context_;
   Pixmap pixmap_;
   GLXPixmap glx_pixmap_;
 
   DISALLOW_COPY_AND_ASSIGN(PixmapGLContext);
 };
 
 // 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);
   }
 };
 
-// Some versions of NVIDIA's GL libGL.so include a broken version of
-// dlopen/dlsym, and so linking it into chrome breaks it. So we dynamically
-// load it, and use glew to dynamically resolve symbols.
-// See http://code.google.com/p/chromium/issues/detail?id=16800
-
 static bool InitializeOneOff() {
   static bool initialized = false;
   if (initialized)
     return true;
 
-  osmewInit();
-  if (!OSMesaCreateContext) {
-    void* handle = dlopen("libGL.so.1", RTLD_LAZY | RTLD_GLOBAL);
-    if (!handle) {
-      LOG(ERROR) << "Could not find libGL.so.1";
-      return false;
-    }
+  // Initialize the GL bindings if they haven't already been initialized. If
+  // the GPU unit tests are running, the mock GL implementation will already
+  // have been initialized.
+  if (!InitializeGLBindings(kGLImplementationDesktopGL)) {
+    LOG(ERROR) << "Could not initialize GL.";
+    return false;
+  }
 
-    // Initializes context-independent parts of GLEW
-    if (glxewInit() != GLEW_OK) {
-      LOG(ERROR) << "glxewInit failed";
-      return false;
-    }
-    // glxewContextInit really only needs a display connection to
-    // complete, and we don't want to have to create an OpenGL context
-    // just to get access to GLX 1.3 entry points to create pbuffers.
-    // We therefore added a glxewContextInitWithDisplay entry point.
+  // Only check the GLX version if we are in fact using GLX. We might actually
+  // be using the mock GL implementation.
+  if (GetGLImplementation() == kGLImplementationDesktopGL) {
     Display* display = x11_util::GetXDisplay();
-    if (glxewContextInitWithDisplay(display) != GLEW_OK) {
-      LOG(ERROR) << "glxewContextInit failed";
-      return false;
-    }
-
     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.";
     }
   }
@@ skipping 29 matching lines @@
     LOG(ERROR) << "Couldn't create GL context.";
     return false;
   }
 
   if (!MakeCurrent()) {
     Destroy();
     LOG(ERROR) << "Couldn't make context current for initialization.";
     return false;
   }
 
-  if (!InitializeGLEW()) {
-    Destroy();
-    return false;
-  }
-
   if (!InitializeCommon()) {
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void ViewGLContext::Destroy() {
   Display* display = x11_util::GetXDisplay();
-  Bool result = glXMakeCurrent(display, 0, 0);
+  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;
   }
 }
@@ skipping 37 matching lines @@
 
 void* ViewGLContext::GetHandle() {
   return context_;
 }
 
 GLContext* GLContext::CreateViewGLContext(gfx::PluginWindowHandle window,
                                           bool multisampled) {
   if (!InitializeOneOff())
     return NULL;
 
-  if (OSMesaCreateContext) {
-    // TODO(apatrick): Support OSMesa rendering to a window on Linux.
-    NOTREACHED() << "OSMesa rendering to a window is not yet implemented.";
-    return NULL;
-  } else {
-    scoped_ptr<ViewGLContext> context(new ViewGLContext(window));
+  switch (GetGLImplementation()) {
+    case kGLImplementationDesktopGL: {
+      scoped_ptr<ViewGLContext> context(new ViewGLContext(window));
 
-    if (!context->Initialize(multisampled))
+      if (!context->Initialize(multisampled))
+        return NULL;
+
+      return context.release();
+    }
+    case kGLImplementationMockGL:
+      return new StubGLContext;
+    default:
+      NOTREACHED();
       return NULL;
-
-    return context.release();
   }
 }
 
-bool PbufferGLContext::Initialize(void* shared_handle) {
-  if (!glXChooseFBConfig ||
-      !glXCreateNewContext ||
-      !glXCreatePbuffer ||
-      !glXDestroyPbuffer) {
-    LOG(ERROR) << "Pbuffer support not available.";
-    return false;
-  }
-
+bool PbufferGLContext::Initialize(GLContext* shared_context) {
   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();
 
   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) {
     LOG(ERROR) << "glXChooseFBConfig returned 0 elements.";
     return false;
   }
+
+  GLContextHandle shared_handle = NULL;
+  if (shared_context)
+    shared_handle = static_cast<GLContextHandle>(shared_context->GetHandle());
+
   context_ = glXCreateNewContext(display,
                                  config.get()[0],
                                  GLX_RGBA_TYPE,
-                                 static_cast<GLContextHandle>(shared_handle),
+                                 shared_handle,
                                  True);
   if (!context_) {
     LOG(ERROR) << "glXCreateNewContext failed.";
     return false;
   }
   static const int pbuffer_attributes[] = {
     GLX_PBUFFER_WIDTH,
     1,
     GLX_PBUFFER_HEIGHT,
     1,
     0
   };
   pbuffer_ = glXCreatePbuffer(display,
                               config.get()[0], pbuffer_attributes);
   if (!pbuffer_) {
     Destroy();
     LOG(ERROR) << "glXCreatePbuffer failed.";
     return false;
   }
 
   if (!MakeCurrent()) {
     Destroy();
     LOG(ERROR) << "Couldn't make context current for initialization.";
     return false;
   }
 
-  if (!InitializeGLEW()) {
-    Destroy();
-    return false;
-  }
-
   if (!InitializeCommon()) {
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void PbufferGLContext::Destroy() {
   Display* display = x11_util::GetXDisplay();
-  Bool result = glXMakeCurrent(display, 0, 0);
+  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_) {
@@ skipping 32 matching lines @@
 
 gfx::Size PbufferGLContext::GetSize() {
   NOTREACHED() << "Should not be requesting size of this pbuffer.";
   return gfx::Size(1, 1);
 }
 
 void* PbufferGLContext::GetHandle() {
   return context_;
 }
 
-bool PixmapGLContext::Initialize(void* shared_handle) {
+bool PixmapGLContext::Initialize(GLContext* shared_context) {
   LOG(INFO) << "GL context: using pixmaps.";
-  if (!glXChooseVisual ||
-      !glXCreateGLXPixmap ||
-      !glXDestroyGLXPixmap) {
-    LOG(ERROR) << "Pixmap support not available.";
-    return false;
-  }
 
   static int attributes[] = {
     GLX_RGBA,
     0
   };
 
   Display* display = x11_util::GetXDisplay();
   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;
   }
-  context_ = glXCreateContext(display, visual_info.get(),
-                              static_cast<GLContextHandle>(shared_handle),
-                              True);
+
+  GLContextHandle shared_handle = NULL;
+  if (shared_context)
+    shared_handle = static_cast<GLContextHandle>(shared_context->GetHandle());
+
+  context_ = glXCreateContext(display, visual_info.get(), shared_handle, True);
   if (!context_) {
     LOG(ERROR) << "glXCreateContext failed.";
     return false;
   }
 
   pixmap_ = XCreatePixmap(display, RootWindow(display, screen), 1, 1,
                           visual_info->depth);
   if (!pixmap_) {
     LOG(ERROR) << "XCreatePixmap failed.";
     return false;
   }
 
   glx_pixmap_ = glXCreateGLXPixmap(display, visual_info.get(), pixmap_);
   if (!glx_pixmap_) {
     LOG(ERROR) << "XCreatePixmap failed.";
     return false;
   }
 
   if (!MakeCurrent()) {
     Destroy();
     LOG(ERROR) << "Couldn't make context current for initialization.";
     return false;
   }
 
-  if (!InitializeGLEW()) {
-    Destroy();
-    return false;
-  }
-
   if (!InitializeCommon()) {
     Destroy();
     return false;
   }
 
   return true;
 }
 
 void PixmapGLContext::Destroy() {
   Display* display = x11_util::GetXDisplay();
-  Bool result = glXMakeCurrent(display, 0, 0);
+  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_) {
@@ skipping 37 matching lines @@
 
 gfx::Size PixmapGLContext::GetSize() {
   NOTREACHED() << "Should not be requesting size of this pixmap.";
   return gfx::Size(1, 1);
 }
 
 void* PixmapGLContext::GetHandle() {
   return context_;
 }
 
-GLContext* GLContext::CreateOffscreenGLContext(void* shared_handle) {
+GLContext* GLContext::CreateOffscreenGLContext(GLContext* shared_context) {
   if (!InitializeOneOff())
     return NULL;
 
-  if (OSMesaCreateContext) {
-    scoped_ptr<OSMesaGLContext> context(new OSMesaGLContext);
+  switch (GetGLImplementation()) {
+    case kGLImplementationDesktopGL: {
+      scoped_ptr<PbufferGLContext> context(new PbufferGLContext);
+      if (context->Initialize(shared_context))
+        return context.release();
 
-    if (!context->Initialize(shared_handle))
+      scoped_ptr<PixmapGLContext> context_pixmap(new PixmapGLContext);
+      if (context_pixmap->Initialize(shared_context))
+        return context_pixmap.release();
+
       return NULL;
-
-    return context.release();
-  } else {
-    scoped_ptr<PbufferGLContext> context(new PbufferGLContext);
-    if (context->Initialize(shared_handle))
-      return context.release();
-
-    scoped_ptr<PixmapGLContext> context_pixmap(new PixmapGLContext);
-    if (context_pixmap->Initialize(shared_handle))
-      return context_pixmap.release();
-
-    return NULL;
+    }
+    case kGLImplementationMockGL:
+      return new StubGLContext;
+    default:
+      NOTREACHED();
+      return NULL;
   }
 }
 
 }  // namespace gfx