Implement GLX for Ozone X11.

ui/gl/gl_surface_x11.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.
 
 #include "ui/gl/gl_surface.h"
 
 #include <stdint.h>
+#include <X11/Xlib.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/trace_event/trace_event.h"
+#include "ui/events/platform/platform_event_dispatcher.h"
+#include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_surface_egl_x11.h"
 #include "ui/gl/gl_surface_glx.h"
 #include "ui/gl/gl_surface_osmesa.h"
 #include "ui/gl/gl_surface_stub.h"
 
 namespace gfx {
 
+namespace {
+
 // This OSMesa GL surface can use XLib to swap the contents of the buffer to a
 // view.
 class NativeViewGLSurfaceOSMesa : public GLSurfaceOSMesa {
  public:
   explicit NativeViewGLSurfaceOSMesa(gfx::AcceleratedWidget window);
 
   static bool InitializeOneOff();
 
   // Implement a subset of GLSurface.
   bool Initialize(GLSurface::Format format) override;
@@ skipping 12 matching lines @@
  private:
   Display* xdisplay_;
   GC window_graphics_context_;
   gfx::AcceleratedWidget window_;
   GC pixmap_graphics_context_;
   Pixmap pixmap_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceOSMesa);
 };
 
-bool GLSurface::InitializeOneOffInternal() {
-  switch (GetGLImplementation()) {
-    case kGLImplementationDesktopGL:
-      if (!GLSurfaceGLX::InitializeOneOff()) {
-        LOG(ERROR) << "GLSurfaceGLX::InitializeOneOff failed.";
-        return false;
-      }
-      break;
-    case kGLImplementationOSMesaGL:
-      if (!NativeViewGLSurfaceOSMesa::InitializeOneOff()) {
-        LOG(ERROR) << "NativeViewGLSurfaceOSMesa::InitializeOneOff failed.";
-        return false;
-      }
-      break;
-    case kGLImplementationEGLGLES2:
-      if (!GLSurfaceEGL::InitializeOneOff()) {
-        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
-        return false;
-      }
-      break;
-    default:
-      break;
-  }
-
-  return true;
-}
-
 NativeViewGLSurfaceOSMesa::NativeViewGLSurfaceOSMesa(
     gfx::AcceleratedWidget window)
     : GLSurfaceOSMesa(SURFACE_OSMESA_BGRA, gfx::Size(1, 1)),
       xdisplay_(gfx::GetXDisplay()),
       window_graphics_context_(0),
       window_(window),
       pixmap_graphics_context_(0),
       pixmap_(0) {
   DCHECK(xdisplay_);
   DCHECK(window_);
@@ skipping 165 matching lines @@
             x,
             y);
 
   return gfx::SwapResult::SWAP_ACK;
 }
 
 NativeViewGLSurfaceOSMesa::~NativeViewGLSurfaceOSMesa() {
   Destroy();
 }
 
+// Native X11 specific implementation of GLX surface. Registers as a
+// PlatformEventDispatcher to handle XEvents.
+class GL_EXPORT NativeViewGLSurfaceGLXX11 : public NativeViewGLSurfaceGLX,
+                                            public ui::PlatformEventDispatcher {
+ public:
+  explicit NativeViewGLSurfaceGLXX11(gfx::AcceleratedWidget window);
+
+  // PlatformEventDispatcher implementation:
+  bool CanDispatchEvent(const ui::PlatformEvent& event) override;
+  uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
+
+ protected:
+  ~NativeViewGLSurfaceGLXX11() override;
+
+  // NativeViewGLSurfaceGLX implementation:
+  void RegisterEvents() override;
+  void UnregisterEvents() override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeViewGLSurfaceGLXX11);
+};
+
+NativeViewGLSurfaceGLXX11::NativeViewGLSurfaceGLXX11(
+    gfx::AcceleratedWidget window)
+    : NativeViewGLSurfaceGLX(window) {}
+
+bool NativeViewGLSurfaceGLXX11::CanDispatchEvent(
+    const ui::PlatformEvent& event) {
+  return CanHandleEvent(event);
+}
+
+uint32_t NativeViewGLSurfaceGLXX11::DispatchEvent(
+    const ui::PlatformEvent& event) {
+  ForwardExposeEvent(event);
+  return ui::POST_DISPATCH_STOP_PROPAGATION;
+}
+
+NativeViewGLSurfaceGLXX11::~NativeViewGLSurfaceGLXX11() {
+  Destroy();
+}
+
+void NativeViewGLSurfaceGLXX11::RegisterEvents() {
+  ui::PlatformEventSource* event_source =
+      ui::PlatformEventSource::GetInstance();
+  // Can be nullptr in tests, when we don't care about Exposes.
+  if (event_source) {
+    XSelectInput(gfx::GetXDisplay(), window(), ExposureMask);
+    event_source->AddPlatformEventDispatcher(this);
+  }
+}
+
+void NativeViewGLSurfaceGLXX11::UnregisterEvents() {
+  ui::PlatformEventSource* event_source =
+      ui::PlatformEventSource::GetInstance();
+  if (event_source)
+    event_source->RemovePlatformEventDispatcher(this);
+}
+
+}  // namespace
+
+bool GLSurface::InitializeOneOffInternal() {
+  switch (GetGLImplementation()) {
+    case kGLImplementationDesktopGL:
+      if (!GLSurfaceGLX::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceGLX::InitializeOneOff failed.";
+        return false;
+      }
+      break;
+    case kGLImplementationOSMesaGL:
+      if (!NativeViewGLSurfaceOSMesa::InitializeOneOff()) {
+        LOG(ERROR) << "NativeViewGLSurfaceOSMesa::InitializeOneOff failed.";
+        return false;
+      }
+      break;
+    case kGLImplementationEGLGLES2:
+      if (!GLSurfaceEGL::InitializeOneOff()) {
+        LOG(ERROR) << "GLSurfaceEGL::InitializeOneOff failed.";
+        return false;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return true;
+}
+
 scoped_refptr<GLSurface> GLSurface::CreateViewGLSurface(
     gfx::AcceleratedWidget window) {
   TRACE_EVENT0("gpu", "GLSurface::CreateViewGLSurface");
   switch (GetGLImplementation()) {
     case kGLImplementationOSMesaGL: {
       scoped_refptr<GLSurface> surface(
           new NativeViewGLSurfaceOSMesa(window));
       if (!surface->Initialize())
         return NULL;
 
       return surface;
     }
     case kGLImplementationDesktopGL: {
-      scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceGLX(window));
+      scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceGLXX11(window));
       if (!surface->Initialize())
         return NULL;
 
       return surface;
     }
     case kGLImplementationEGLGLES2: {
       DCHECK(window != gfx::kNullAcceleratedWidget);
       scoped_refptr<GLSurface> surface(new NativeViewGLSurfaceEGLX11(window));
       if (!surface->Initialize())
         return NULL;
@@ skipping 41 matching lines @@
       NOTREACHED();
       return NULL;
   }
 }
 
 EGLNativeDisplayType GetPlatformDefaultEGLNativeDisplay() {
   return gfx::GetXDisplay();
 }
 
 }  // namespace gfx