Implement GLX for Ozone X11.

ui/gl/gl_surface_glx.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_glx.h"
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 #include <memory>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
-#include "ui/events/platform/platform_event_source.h"
 #include "ui/gfx/x/x11_connection.h"
 #include "ui/gfx/x/x11_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/sync_control_vsync_provider.h"
 
 namespace gfx {
 
 namespace {
 
@@ skipping 399 matching lines @@
   return g_glx_oml_sync_control_supported;
 }
 
 void* GLSurfaceGLX::GetDisplay() {
   return g_display;
 }
 
 GLSurfaceGLX::~GLSurfaceGLX() {}
 
 NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window)
-    : parent_window_(window), window_(0), glx_window_(0), config_(nullptr) {
-}
+    : parent_window_(window), window_(0), glx_window_(0), config_(nullptr) {}
 
 GLXDrawable NativeViewGLSurfaceGLX::GetDrawableHandle() const {
   return glx_window_;
 }
 
 bool NativeViewGLSurfaceGLX::Initialize(GLSurface::Format format) {
   XWindowAttributes attributes;
   if (!XGetWindowAttributes(g_display, parent_window_, &attributes)) {
     LOG(ERROR) << "XGetWindowAttributes failed for window " << parent_window_
         << ".";
     return false;
   }
   size_ = gfx::Size(attributes.width, attributes.height);
   // Create a child window, with a CopyFromParent visual (to avoid inducing
   // extra blits in the driver), that we can resize exactly in Resize(),
   // correctly ordered with GL, so that we don't have invalid transient states.
   // See https://crbug.com/326995.
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = 0;
   swa.bit_gravity = NorthWestGravity;
   window_ = XCreateWindow(g_display, parent_window_, 0, 0, size_.width(),
                           size_.height(), 0, CopyFromParent, InputOutput,
                           CopyFromParent, CWBackPixmap | CWBitGravity, &swa);
   XMapWindow(g_display, window_);
 
-  ui::PlatformEventSource* event_source =
-      ui::PlatformEventSource::GetInstance();
-  // Can be nullptr in tests, when we don't care about Exposes.
-  if (event_source) {
-    XSelectInput(g_display, window_, ExposureMask);
-    ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
-  }
+  RegisterEvents();
   XFlush(g_display);
 
   GetConfig();
   DCHECK(config_);
   glx_window_ = glXCreateWindow(g_display, config_, window_, NULL);
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(glx_window_));
   else if (g_glx_sgi_video_sync_supported)
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(config_, glx_window_));
 
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
   vsync_provider_.reset();
   if (glx_window_) {
     glXDestroyWindow(g_display, glx_window_);
     glx_window_ = 0;
   }
   if (window_) {
-    ui::PlatformEventSource* event_source =
-        ui::PlatformEventSource::GetInstance();
-    if (event_source)
-      event_source->RemovePlatformEventDispatcher(this);
+    UnregisterEvents();
     XDestroyWindow(g_display, window_);
     window_ = 0;
     XFlush(g_display);
   }
 }
 
-bool NativeViewGLSurfaceGLX::CanDispatchEvent(const ui::PlatformEvent& event) {
-  return event->type == Expose && event->xexpose.window == window_;
-}
-
-uint32_t NativeViewGLSurfaceGLX::DispatchEvent(const ui::PlatformEvent& event) {
-  XEvent forwarded_event = *event;
-  forwarded_event.xexpose.window = parent_window_;
-  XSendEvent(g_display, parent_window_, False, ExposureMask,
-             &forwarded_event);
-  XFlush(g_display);
-  return ui::POST_DISPATCH_STOP_PROPAGATION;
-}
-
 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size,
                                     float scale_factor,
                                     bool has_alpha) {
   size_ = size;
   glXWaitGL();
   XResizeWindow(g_display, window_, size.width(), size.height());
   glXWaitX();
   return true;
 }
 
@@ skipping 38 matching lines @@
 }
 
 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
+void NativeViewGLSurfaceGLX::ForwardExposeEvent(XEvent* event) {
+  XEvent forwarded_event = *event;
+  forwarded_event.xexpose.window = parent_window_;
+  XSendEvent(g_display, parent_window_, False, ExposureMask, &forwarded_event);
+  XFlush(g_display);
+}
+
+bool NativeViewGLSurfaceGLX::CanHandleEvent(XEvent* event) {
+  return event->type == Expose &&
+         event->xexpose.window == static_cast<Window>(window_);
+}
+
 UnmappedNativeViewGLSurfaceGLX::UnmappedNativeViewGLSurfaceGLX(
     const gfx::Size& size)
     : size_(size), config_(nullptr), window_(0), glx_window_(0) {
   // Ensure that we don't create a window with zero size.
   if (size_.GetArea() == 0)
     size_.SetSize(1, 1);
 }
 
 bool UnmappedNativeViewGLSurfaceGLX::Initialize(GLSurface::Format format) {
   DCHECK(!window_);
@@ skipping 46 matching lines @@
   if (!config_)
     config_ = GetConfigForWindow(g_display, window_);
   return config_;
 }
 
 UnmappedNativeViewGLSurfaceGLX::~UnmappedNativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx