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

ui/display/chromeos/x11/native_display_event_dispatcher_x11.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 "base/time/default_tick_clock.h"
 #include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
 #include "ui/display/chromeos/x11/display_mode_x11.h"
 #include "ui/display/chromeos/x11/display_snapshot_x11.h"
+#include "ui/events/platform/platform_event_source.h"
 
 #include <X11/extensions/Xrandr.h>
 
 namespace ui {
 
 // static
 const int NativeDisplayEventDispatcherX11::kCachedOutputsExpirationMs = 5000;
 
 NativeDisplayEventDispatcherX11::NativeDisplayEventDispatcherX11(
     NativeDisplayDelegateX11::HelperDelegate* delegate,
     int xrandr_event_base)
     : delegate_(delegate),
       xrandr_event_base_(xrandr_event_base),
       tick_clock_(new base::DefaultTickClock) {}
 
 NativeDisplayEventDispatcherX11::~NativeDisplayEventDispatcherX11() {}
 
-uint32_t NativeDisplayEventDispatcherX11::Dispatch(
-    const base::NativeEvent& event) {
+bool NativeDisplayEventDispatcherX11::CanDispatchEvent(
+    const PlatformEvent& event) {
+  return (event->type - xrandr_event_base_ == RRScreenChangeNotify) ||
+         (event->type - xrandr_event_base_ == RRNotify);
+}
+
+uint32_t NativeDisplayEventDispatcherX11::DispatchEvent(
+    const PlatformEvent& event) {
   if (event->type - xrandr_event_base_ == RRScreenChangeNotify) {
     VLOG(1) << "Received RRScreenChangeNotify event";
     delegate_->UpdateXRandRConfiguration(event);
-    return POST_DISPATCH_PERFORM_DEFAULT;
+    return ui::POST_DISPATCH_PERFORM_DEFAULT;
   }
 
   // Bail out early for everything except RRNotify_OutputChange events
   // about an output getting connected or disconnected.
   if (event->type - xrandr_event_base_ != RRNotify)
-    return POST_DISPATCH_PERFORM_DEFAULT;
+    return ui::POST_DISPATCH_PERFORM_DEFAULT;
   const XRRNotifyEvent* notify_event = reinterpret_cast<XRRNotifyEvent*>(event);
   if (notify_event->subtype != RRNotify_OutputChange)
-    return POST_DISPATCH_PERFORM_DEFAULT;
+    return ui::POST_DISPATCH_PERFORM_DEFAULT;
   const XRROutputChangeNotifyEvent* output_change_event =
       reinterpret_cast<XRROutputChangeNotifyEvent*>(event);
   const int action = output_change_event->connection;
   if (action != RR_Connected && action != RR_Disconnected)
-    return POST_DISPATCH_PERFORM_DEFAULT;
+    return ui::POST_DISPATCH_PERFORM_DEFAULT;
 
   const bool connected = (action == RR_Connected);
   VLOG(1) << "Received RRNotify_OutputChange event:"
           << " output=" << output_change_event->output
           << " crtc=" << output_change_event->crtc
           << " mode=" << output_change_event->mode
           << " action=" << (connected ? "connected" : "disconnected");
 
   bool force_notify = last_notified_time_.is_null() ||
       (tick_clock_->NowTicks() - last_notified_time_).InMilliseconds() >=
@@ skipping 17 matching lines @@
           VLOG(1) << "Ignoring event describing already-cached state";
           return POST_DISPATCH_PERFORM_DEFAULT;
         }
         found_changed_output = true;
         break;
       }
     }
 
     if (!connected && !found_changed_output) {
       VLOG(1) << "Ignoring event describing already-disconnected output";
-      return POST_DISPATCH_PERFORM_DEFAULT;
+      return ui::POST_DISPATCH_PERFORM_DEFAULT;
     }
   }
 
   last_notified_time_ = tick_clock_->NowTicks();
 
   delegate_->NotifyDisplayObservers();
 
-  return POST_DISPATCH_PERFORM_DEFAULT;
+  return ui::POST_DISPATCH_PERFORM_DEFAULT;
 }
 
 void NativeDisplayEventDispatcherX11::SetTickClockForTest(
     scoped_ptr<base::TickClock> tick_clock) {
   tick_clock_ = tick_clock.Pass();
 }
 
 }  // namespace ui