Implement GLX for Ozone X11.

ui/gl/gl_surface_ozone.cc

 // Copyright 2014 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.
 
 #include "ui/gl/gl_surface.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 14 matching lines @@
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_overlay.h"
 #include "ui/gl/gl_surface_stub.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_egl.h"
 
+#if defined(USE_GLX)
+#include <X11/Xlib.h>
+
+#include "ui/events/platform/x11/x11_event_source_libevent.h"
+#include "ui/gl/gl_surface_glx.h"
+#endif
+
 using gl::GLImage;
 
 namespace gfx {
 
 namespace {
 
 // Helper function for base::Bind to create callback to eglChooseConfig.
 bool EglChooseConfig(EGLDisplay display,
                      const int32_t* attribs,
                      EGLConfig* configs,
@@ skipping 599 matching lines @@
       images_[i]->Destroy(true);
     images_[i] = image;
     // Bind image to texture.
     ScopedTextureBinder binder(GL_TEXTURE_2D, textures_[i]);
     if (!images_[i]->BindTexImage(GL_TEXTURE_2D))
       return false;
   }
   return true;
 }
 
+#if defined(USE_GLX)
+
+// Ozone specific implementation of GLX surface. Registers as XEventDispatcher
+// to handle XEvents.
+class GL_EXPORT NativeViewGLSurfaceGLXOzone : public NativeViewGLSurfaceGLX,
+                                              public ui::XEventDispatcher {

[sadrul, 2016/04/19 14:49:49]

Can this not use the PlatformEventDispatcher interface instead?

[kylechar, 2016/04/19 16:00:20]

No, Expose events are platform specific and we don't have any way to encode them
as a ui::Event under Ozone.

+ public:
+  explicit NativeViewGLSurfaceGLXOzone(gfx::AcceleratedWidget window);
+
+  // XEventDispatcher implementation:
+  bool DispatchXEvent(XEvent* xevent) override;
+
+ protected:
+  ~NativeViewGLSurfaceGLXOzone() override;
+
+  // NativeViewGLSurfaceGLX implementation:
+  void RegisterEvents() override;
+  void UnregisterEvents() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceGLXOzone);
+};
+
+NativeViewGLSurfaceGLXOzone::NativeViewGLSurfaceGLXOzone(
+    gfx::AcceleratedWidget window)
+    : NativeViewGLSurfaceGLX(window) {}
+
+bool NativeViewGLSurfaceGLXOzone::DispatchXEvent(XEvent* event) {
+  if (!CanHandleEvent(event))
+    return false;
+
+  ForwardExposeEvent(event);
+  return true;
+}
+
+NativeViewGLSurfaceGLXOzone::~NativeViewGLSurfaceGLXOzone() {
+  Destroy();
+}
+
+void NativeViewGLSurfaceGLXOzone::RegisterEvents() {
+  ui::X11EventSourceLibevent* event_source =
+      ui::X11EventSourceLibevent::GetInstance();
+  // Can be nullptr in tests, when we don't care about Exposes.
+  if (event_source) {
+    XSelectInput(gfx::GetXDisplay(), window(), ExposureMask);
+    event_source->AddXEventDispatcher(this);
+  }
+}
+
+void NativeViewGLSurfaceGLXOzone::UnregisterEvents() {
+  ui::X11EventSourceLibevent* event_source =
+      ui::X11EventSourceLibevent::GetInstance();
+  if (event_source)
+    event_source->RemoveXEventDispatcher(this);
+}
+
+#endif  // defined(USE_GLX)
+
 scoped_refptr<GLSurface> CreateViewGLSurfaceOzone(
     gfx::AcceleratedWidget window) {
   scoped_ptr<ui::SurfaceOzoneEGL> surface_ozone =
       ui::OzonePlatform::GetInstance()
           ->GetSurfaceFactoryOzone()
           ->CreateEGLSurfaceForWidget(window);
   if (!surface_ozone)
     return nullptr;
   scoped_refptr<GLSurface> surface =
       new GLSurfaceOzoneEGL(std::move(surface_ozone), window);
@@ skipping 15 matching lines @@
   if (!surface->Initialize())
     return nullptr;
   return surface;
 }
 
 }  // namespace
 
 // static
 bool GLSurface::InitializeOneOffInternal() {
   switch (GetGLImplementation()) {
+#if defined(USE_GLX)
+    case kGLImplementationDesktopGL:
+      if (!GLSurfaceGLX::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceGLX::InitializeOneOff failed.";
+        return false;
+      }
+
+      return true;
+#endif
     case kGLImplementationEGLGLES2:
       if (!GLSurfaceEGL::InitializeOneOff()) {
         LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
         return false;
       }
 
       return true;
     case kGLImplementationOSMesaGL:
     case kGLImplementationMockGL:
       return true;
@@ skipping 19 matching lines @@
     if (surface->Initialize())
       return surface;
   }
 
   return nullptr;
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
     gfx::AcceleratedWidget window) {
+#if defined(USE_GLX)
+  if (GetGLImplementation() == kGLImplementationDesktopGL) {
+    scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceGLXOzone(window));
+    if (!surface->Initialize())
+      return nullptr;
+    return surface;
+  }
+#endif
   if (GetGLImplementation() == kGLImplementationOSMesaGL) {
     scoped_refptr<GLSurface> surface(new GLSurfaceOSMesaHeadless());
     if (!surface->Initialize())
       return nullptr;
     return surface;
   }
   DCHECK(GetGLImplementation() == kGLImplementationEGLGLES2);
   if (window != kNullAcceleratedWidget) {
     scoped_refptr<GLSurface> surface;
     if (GLSurfaceEGL::IsEGLSurfacelessContextSupported())
       surface = CreateViewGLSurfaceOzoneSurfacelessSurfaceImpl(window);
     if (!surface)
       surface = CreateViewGLSurfaceOzone(window);
     return surface;
   } else {
     scoped_refptr<GLSurface> surface = new GLSurfaceStub();
     if (surface->Initialize())
       return surface;
   }
   return nullptr;
 }
 
 // static
 scoped_refptr<GLSurface> GLSurface::CreateOffscreenGLSurface(
     const gfx::Size& size) {
   switch (GetGLImplementation()) {
+#if defined(USE_GLX)
+    case kGLImplementationDesktopGL: {
+      scoped_refptr<GLSurface> surface(
+          new UnmappedNativeViewGLSurfaceGLX(size));
+      if (!surface->Initialize())
+        return nullptr;
+
+      return surface;
+    }
+#endif
     case kGLImplementationOSMesaGL: {
       scoped_refptr<GLSurface> surface(
           new GLSurfaceOSMesa(SURFACE_OSMESA_BGRA, size));
       if (!surface->Initialize())
         return nullptr;
 
       return surface;
     }
     case kGLImplementationEGLGLES2: {
       scoped_refptr<GLSurface> surface;
@@ skipping 16 matching lines @@
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->GetNativeDisplay();
 }
 
 }  // namespace gfx