glx: forward Expose event from child window to parent

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.
 
 extern "C" {
 #include <X11/Xlib.h>
 }
 
 #include "ui/gl/gl_surface_glx.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "third_party/mesa/src/include/GL/osmesa.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 384 matching lines @@
                           size_.width(),
                           size_.height(),
                           0,
                           CopyFromParent,
                           InputOutput,
                           CopyFromParent,
                           0,
                           NULL);
   XMapWindow(g_display, window_);
 
+  ui::PlatformEventSource* event_source =
+      ui::PlatformEventSource::GetInstance();
+  // Can be NULL in tests, when we don't care about Exposes.
+  if (event_source) {
+    XSelectInput(g_display, window_, ExposureMask);
+    ui::PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
+  }
+  XFlush(g_display);

[ccameron, 2014/05/23 09:12:00]

I was wondering if this would be needed, looks like it was.

This is all much cleaner than https://chromiumcodereview.appspot.com/23452026.

[piman, 2014/05/23 10:09:48]

I suppose it'll be kinda implicit at the next resize or swap, it just feels
safer.

Since we're not running a traditional XPending/XNextEvent loop, almost nothing
forces a Flush anywhere...

+
   gfx::AcceleratedWidget window_for_vsync = window_;
 
   if (g_glx_oml_sync_control_supported)
     vsync_provider_.reset(new OMLSyncControlVSyncProvider(window_for_vsync));
   else if (g_glx_sgi_video_sync_supported)
     vsync_provider_.reset(new SGIVideoSyncVSyncProvider(window_for_vsync));
 
   return true;
 }
 
 void NativeViewGLSurfaceGLX::Destroy() {
   if (window_) {
+    ui::PlatformEventSource* event_source =
+        ui::PlatformEventSource::GetInstance();
+    if (event_source)
+      event_source->RemovePlatformEventDispatcher(this);
     XDestroyWindow(g_display, window_);
     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;

[ccameron, 2014/05/23 09:12:00]

In the previous incarnation of this, we did a CONTINUE here -- any good reason
to stop the even there? Might there be side effects?

[piman, 2014/05/23 10:09:48]

At this point this is the only class that cares about the events. Stopping
prevents useless dispatches in other instances, since they're the wrong window
anyway.

+}
+
 bool NativeViewGLSurfaceGLX::Resize(const gfx::Size& size) {
   size_ = size;
   glXWaitGL();
   XResizeWindow(g_display, window_, size.width(), size.height());
   glXWaitX();
   return true;
 }
 
 bool NativeViewGLSurfaceGLX::IsOffscreen() {
   return false;
@@ skipping 85 matching lines @@
     int x, int y, int width, int height) {
   DCHECK(gfx::g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   return true;
 }
 
 VSyncProvider* NativeViewGLSurfaceGLX::GetVSyncProvider() {
   return vsync_provider_.get();
 }
 
-NativeViewGLSurfaceGLX::NativeViewGLSurfaceGLX()
-  : parent_window_(0),
-    window_(0),
-    config_(NULL) {
-}
-
 NativeViewGLSurfaceGLX::~NativeViewGLSurfaceGLX() {
   Destroy();
 }
 
 PbufferGLSurfaceGLX::PbufferGLSurfaceGLX(const gfx::Size& size)
   : size_(size),
     config_(NULL),
     pbuffer_(0) {
 }
 
@@ skipping 74 matching lines @@
 
 void* PbufferGLSurfaceGLX::GetConfig() {
   return config_;
 }
 
 PbufferGLSurfaceGLX::~PbufferGLSurfaceGLX() {
   Destroy();
 }
 
 }  // namespace gfx