X11: Add window cache

ui/events/platform/x11/x11_event_source.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/events/platform/x11/x11_event_source.h"
 
 #include <X11/Xatom.h>
 #include <X11/XKBlib.h>
 #include <X11/Xlib.h>
+#include <X11/Xlib-xcb.h>
+#include <xcb/xcbext.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "ui/base/x/x11_window_event_manager.h"
 #include "ui/events/devices/x11/device_data_manager_x11.h"
 #include "ui/events/devices/x11/touch_factory_x11.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
 #include "ui/events/platform/x11/x11_hotplug_event_handler.h"
 
+#define XLIB_SEQUENCE_COMPARE(a, op, b) (((int64_t)(a) - (int64_t)(b)) op 0)
+
 namespace ui {
 
 namespace {
 
 bool InitializeXkb(XDisplay* display) {
   if (!display)
     return false;
 
   int opcode, event, error;
   int major = XkbMajorVersion;
@@ skipping 55 matching lines @@
                                   XEvent* event,
                                   XPointer arg) {
   return event->type == PropertyNotify &&
          event->xproperty.window == *reinterpret_cast<Window*>(arg);
 }
 
 }  // namespace
 
 X11EventSource* X11EventSource::instance_ = nullptr;
 
+X11EventSource::Request::Request(uint32_t sequence)
+    : sequence_(sequence), weak_factory_(this) {}
+X11EventSource::Request::~Request() {}
+
+base::WeakPtr<X11EventSource::Request> X11EventSource::Request::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
 X11EventSource::X11EventSource(X11EventSourceDelegate* delegate,
                                XDisplay* display)
     : delegate_(delegate),
       display_(display),
+      connection_(XGetXCBConnection(display_)),
       dummy_initialized_(false),
+      next_reply_(nullptr),
+      next_error_(nullptr),
       continue_stream_(true) {
   DCHECK(!instance_);
   instance_ = this;
 
   DCHECK(delegate_);
   DCHECK(display_);
   DeviceDataManagerX11::CreateInstance();
   InitializeXkb(display_);
 }
 
 X11EventSource::~X11EventSource() {
   DCHECK_EQ(this, instance_);
+  DCHECK(!next_reply_ && !next_error_);
   instance_ = nullptr;
   if (dummy_initialized_)
     XDestroyWindow(display_, dummy_window_);
 }
 
 bool X11EventSource::HasInstance() {
   return instance_;
 }
 
 // static
 X11EventSource* X11EventSource::GetInstance() {
   DCHECK(instance_);
   return instance_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // X11EventSource, public
 
 void X11EventSource::DispatchXEvents() {
   DCHECK(display_);
   // Handle all pending events.
   // It may be useful to eventually align this event dispatch with vsync, but
   // not yet.
   continue_stream_ = true;
-  while (XPending(display_) && continue_stream_) {
-    XEvent xevent;
-    XNextEvent(display_, &xevent);
-    ExtractCookieDataDispatchEvent(&xevent);
+
+  // Read all available data.
+  XEventsQueued(display_, QueuedAfterReading);
+
+  while (HasNextReply() && HasNextEvent() && continue_stream_) {
+    if (XLIB_SEQUENCE_COMPARE(NextReplySequence(), <=, NextEventSequence()))
+      ProcessNextReply();
+    else
+      ProcessNextEvent();
   }
+
+  while (HasNextReply() && continue_stream_)
+    ProcessNextReply();
+
+  while (HasNextEvent() && continue_stream_)
+    ProcessNextEvent();
 }
 
 void X11EventSource::DispatchXEventNow(XEvent* event) {
   ExtractCookieDataDispatchEvent(event);
 }
 
 void X11EventSource::BlockUntilWindowMapped(XID window) {
   BlockOnWindowStructureEvent(window, MapNotify);
 }
 
@@ skipping 62 matching lines @@
       if (!ui::TouchFactory::GetInstance()->ShouldProcessXI2Event(event))
         break;
       is_valid_event = true;
   }
 
   if (is_valid_event)
     return ui::EventSystemLocationFromNative(event);
   return base::nullopt;
 }
 
+void X11EventSource::EnqueueRequest(Request* request) {
+  DCHECK(request);
+  request_queue_.emplace_back(request);
+  request->it_ = --request_queue_.end();
+}
+
+void X11EventSource::DiscardRequest(Request* request) {
+  DCHECK(connection_);
+  if ((next_reply_ || next_error_) && request == request_queue_.front().get()) {
+    free(next_reply_);
+    free(next_error_);
+    next_reply_ = nullptr;
+    next_error_ = nullptr;
+  } else {
+    xcb_discard_reply(connection_, request->sequence());
+  }
+  request_queue_.erase(request->it_);
+}
+
+bool X11EventSource::DispatchRequestNow(Request* request) {
+  DCHECK(connection_);
+
+  bool success = false;
+  if ((next_reply_ || next_error_) && request == request_queue_.front().get()) {
+    success = !next_error_;
+    ProcessNextReply();
+  } else {
+    xcb_generic_error_t* error = nullptr;
+    void* reply = xcb_wait_for_reply(connection_, request->sequence(), &error);
+    success = !error;
+    ProcessRequest(request, reinterpret_cast<xcb_generic_reply_t*>(reply),
+                   error);
+    free(reply);
+    free(error);
+  }
+  return success;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // X11EventSource, protected
 
 void X11EventSource::ExtractCookieDataDispatchEvent(XEvent* xevent) {
   bool have_cookie = false;
   if (xevent->type == GenericEvent &&
       XGetEventData(xevent->xgeneric.display, &xevent->xcookie)) {
     have_cookie = true;
   }
 
@@ skipping 43 matching lines @@
 void X11EventSource::BlockOnWindowStructureEvent(XID window, int type) {
   XEvent event;
   do {
     // Block until there's a StructureNotify event of |type| on |window|. Then
     // remove it from the queue and stuff it in |event|.
     XWindowEvent(display_, window, StructureNotifyMask, &event);
     ExtractCookieDataDispatchEvent(&event);
   } while (event.type != type);
 }
 
+bool X11EventSource::HasNextReply() {
+  if (request_queue_.empty() || xcb_connection_has_error(connection_))
+    return false;
+  if (next_reply_ || next_error_)
+    return true;
+
+  return xcb_poll_for_reply(connection_, request_queue_.front()->sequence(),
+                            &next_reply_, &next_error_);
+}
+
+uint32_t X11EventSource::NextReplySequence() {
+  DCHECK(HasNextReply());
+  return request_queue_.front()->sequence();
+}
+
+void X11EventSource::ProcessRequest(Request* request,
+                                    xcb_generic_reply_t* reply,
+                                    xcb_generic_error_t* error) {
+  base::WeakPtr<Request> weak_ptr = request->GetWeakPtr();
+  request->OnReply(reply, error);
+  // OnReply() may have chosen to discard this request already.
+  if (weak_ptr)
+    request_queue_.erase(request->it_);
+}
+
+void X11EventSource::ProcessNextReply() {
+  DCHECK(HasNextReply());
+
+  ProcessRequest(request_queue_.front().get(),
+                 reinterpret_cast<xcb_generic_reply_t*>(next_reply_),
+                 next_error_);
+
+  free(next_reply_);
+  free(next_error_);
+  next_reply_ = nullptr;
+  next_error_ = nullptr;
+}
+
+bool X11EventSource::HasNextEvent() {
+  return XEventsQueued(display_, QueuedAlready);
+}
+
+uint32_t X11EventSource::NextEventSequence() {
+  DCHECK(HasNextEvent());
+  XEvent event;
+  XPeekEvent(display_, &event);
+  return event.xany.serial;
+}
+
+void X11EventSource::ProcessNextEvent() {
+  DCHECK(HasNextEvent());
+  XEvent event;
+  XNextEvent(display_, &event);
+  ExtractCookieDataDispatchEvent(&event);
+}
+
 void X11EventSource::StopCurrentEventStream() {
   continue_stream_ = false;
 }
 
 void X11EventSource::OnDispatcherListChanged() {
   if (!hotplug_event_handler_) {
     hotplug_event_handler_.reset(new X11HotplugEventHandler());
     // Force the initial device query to have an update list of active devices.
     hotplug_event_handler_->OnHotplugEvent();
   }
 }
 
 }  // namespace ui