Implement GLX for Ozone X11.

ui/gl/gl_surface_glx.h

 // 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.
 
 #ifndef UI_GL_GL_SURFACE_GLX_H_
 #define UI_GL_GL_SURFACE_GLX_H_
 
 #include <stdint.h>
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/gl/gl_export.h"
 #include "ui/gl/gl_surface.h"
 
 namespace gfx {
 
 // Base class for GLX surfaces.
@@ skipping 20 matching lines @@
   void* GetConfig() override = 0;
 
  protected:
   ~GLSurfaceGLX() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceGLX);
 };
 
 // A surface used to render to a view.
-class GL_EXPORT NativeViewGLSurfaceGLX : public GLSurfaceGLX,
-                                         public ui::PlatformEventDispatcher {
+class GL_EXPORT NativeViewGLSurfaceGLX : public GLSurfaceGLX {
  public:
   explicit NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window);
 
   // Implement GLSurfaceGLX.
   bool Initialize(GLSurface::Format format) override;
   void Destroy() override;
   bool Resize(const gfx::Size& size,
               float scale_factor,
               bool has_alpha) override;
   bool IsOffscreen() override;
   gfx::SwapResult SwapBuffers() override;
   gfx::Size GetSize() override;
   void* GetHandle() override;
   bool SupportsPostSubBuffer() override;
   void* GetConfig() override;
   gfx::SwapResult PostSubBuffer(int x, int y, int width, int height) override;
   VSyncProvider* GetVSyncProvider() override;
 
  protected:
   ~NativeViewGLSurfaceGLX() override;
 
+  // Handle registering and unregistering for Expose events.

[rjkroege, 2016/04/27 19:08:12]

This seems unfortunate. Can you handle this at a lower level? i.e. in the ozone
platform and leave this be? An ozone consumer should not know what platform
implementation sits beneath it.

[kylechar, 2016/04/27 19:36:32]

Not totally sure I understand this part. This abstract base class has no idea
what is happening to get Expose events, it just has some methods to handle them.
Only the subclass which is Ozone implementation specific knows.

+  virtual void RegisterEvents() = 0;
+  virtual void UnregisterEvents() = 0;
+
+  // Forwards Expose event to child window.
+  void ForwardExposeEvent(XEvent* xevent);
+
+  // Checks if event is Expose for child window.
+  bool CanHandleEvent(XEvent* xevent);
+
+  gfx::AcceleratedWidget window() const { return window_; }
+
  private:
   // The handle for the drawable to make current or swap.
   GLXDrawable GetDrawableHandle() const;
 
-  // PlatformEventDispatcher implementation
-  bool CanDispatchEvent(const ui::PlatformEvent& event) override;
-  uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
-
   // Window passed in at creation. Always valid.
   gfx::AcceleratedWidget parent_window_;
 
   // Child window, used to control resizes so that they're in-order with GL.
   gfx::AcceleratedWidget window_;
 
   // GLXDrawable for the window.
   GLXWindow glx_window_;
 
   GLXFBConfig config_;
@@ skipping 29 matching lines @@
 
   // GLXDrawable for the window.
   GLXWindow glx_window_;
 
   DISALLOW_COPY_AND_ASSIGN(UnmappedNativeViewGLSurfaceGLX);
 };
 
 }  // namespace gfx
 
 #endif  // UI_GL_GL_SURFACE_GLX_H_