x11: Move X event handling out of the message-pump.

ui/base/clipboard/clipboard_aurax11.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/base/clipboard/clipboard.h"
 
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <list>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_pump_observer.h"
 #include "base/message_loop/message_pump_x11.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/x/selection_owner.h"
 #include "ui/base/x/selection_requestor.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_util.h"
+#include "ui/events/platform/platform_event_dispatcher.h"
+#include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/x/x11_atom_cache.h"
 
 namespace ui {
 
 namespace {
 
 const char kClipboard[] = "CLIPBOARD";
 const char kMimeTypeFilename[] = "chromium/filename";
@@ skipping 179 matching lines @@
 
 bool Clipboard::FormatType::Equals(const FormatType& other) const {
   return data_ == other.data_;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Clipboard::AuraX11Details
 
 // Private implementation of our X11 integration. Keeps X11 headers out of the
 // majority of chrome, which break badly.
-class Clipboard::AuraX11Details : public base::MessagePumpDispatcher {
+class Clipboard::AuraX11Details : public PlatformEventDispatcher {
  public:
   AuraX11Details();
   virtual ~AuraX11Details();
 
   X11AtomCache* atom_cache() { return &atom_cache_; }
 
   // Returns the X11 type that we pass to various XSelection functions for the
   // given type.
   ::Atom LookupSelectionForClipboardType(ClipboardType type) const;
 
@@ skipping 37 matching lines @@
   // Returns a list of all text atoms that we handle.
   std::vector< ::Atom> GetTextAtoms() const;
 
   // Returns a vector with a |format| converted to an X11 atom.
   std::vector< ::Atom> GetAtomsForFormat(const Clipboard::FormatType& format);
 
   // Clears a certain clipboard type, whether we own it or not.
   void Clear(ClipboardType type);
 
  private:
-  // Overridden from base::MessagePumpDispatcher:
-  virtual uint32_t Dispatch(const base::NativeEvent& event) OVERRIDE;
+  // PlatformEventDispatcher:
+  virtual bool CanDispatchEvent(const PlatformEvent& event) OVERRIDE;
+  virtual uint32_t DispatchEvent(const PlatformEvent& event) OVERRIDE;
 
   // Our X11 state.
   Display* x_display_;
   ::Window x_root_window_;
 
   // Input-only window used as a selection owner.
   ::Window x_window_;
 
   X11AtomCache atom_cache_;
 
@@ skipping 28 matching lines @@
                            atom_cache_.GetAtom(kClipboard)),
       primary_requestor_(x_display_, x_window_, XA_PRIMARY),
       clipboard_owner_(x_display_, x_window_, atom_cache_.GetAtom(kClipboard)),
       primary_owner_(x_display_, x_window_, XA_PRIMARY) {
   // We don't know all possible MIME types at compile time.
   atom_cache_.allow_uncached_atoms();
 
   XStoreName(x_display_, x_window_, "Chromium clipboard");
   XSelectInput(x_display_, x_window_, PropertyChangeMask);
 
-  base::MessagePumpX11::Current()->AddDispatcherForWindow(this, x_window_);
+  if (PlatformEventSource::GetInstance())
+    PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
 }
 
 Clipboard::AuraX11Details::~AuraX11Details() {
-  base::MessagePumpX11::Current()->RemoveDispatcherForWindow(x_window_);
+  if (PlatformEventSource::GetInstance())
+    PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 
   XDestroyWindow(x_display_, x_window_);
 }
 
 ::Atom Clipboard::AuraX11Details::LookupSelectionForClipboardType(
     ClipboardType type) const {
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     return atom_cache_.GetAtom(kClipboard);
 
   return XA_PRIMARY;
@@ skipping 128 matching lines @@
   return atoms;
 }
 
 void Clipboard::AuraX11Details::Clear(ClipboardType type) {
   if (type == CLIPBOARD_TYPE_COPY_PASTE)
     clipboard_owner_.ClearSelectionOwner();
   else
     primary_owner_.ClearSelectionOwner();
 }
 
-uint32_t Clipboard::AuraX11Details::Dispatch(const base::NativeEvent& event) {
-  XEvent* xev = event;
+bool Clipboard::AuraX11Details::CanDispatchEvent(const PlatformEvent& event) {
+  return event->xany.window == x_window_;
+}
 
+uint32_t Clipboard::AuraX11Details::DispatchEvent(const PlatformEvent& xev) {
   switch (xev->type) {
     case SelectionRequest: {
       if (xev->xselectionrequest.selection == XA_PRIMARY)
         primary_owner_.OnSelectionRequest(xev->xselectionrequest);
       else
         clipboard_owner_.OnSelectionRequest(xev->xselectionrequest);
       break;
     }
     case SelectionNotify: {
       if (xev->xselection.selection == XA_PRIMARY)
@@ skipping 361 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 }  // namespace ui