mus: Add EventObserver to allow passively listening to UI events

components/mus/ws/window_manager_state.cc

 // Copyright 2016 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 "components/mus/ws/window_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/platform_display.h"
@@ skipping 208 matching lines @@
   if (event_ack_timer_.IsRunning()) {
     if (!event_queue_.empty() && !event_queue_.back()->processed_target &&
         EventsCanBeCoalesced(*event_queue_.back()->event, event)) {
       event_queue_.back()->event = CoalesceEvents(
           std::move(event_queue_.back()->event), ui::Event::Clone(event));
       return;
     }
     QueueEvent(event, nullptr);
     return;
   }
+
+  // Only send events to any event observers after the previous event was acked,
+  // to maintain ordering with events sent via normal dispatch.
+  // TODO(jamescook): If the event dispatcher finds a target window, and that
+  // window's window tree has an event observer that matches the event, just
+  // send the event once via normal dispatch and let the client library trigger
+  // its event observer mechanism. http://crbug.com/605580
+  window_server()->SendToEventObservers(event);

[sky, 2016/04/21 17:23:03]

This comment doesn't match with the code. This function is called when Display
gets an Event, before EventDispatcher has processed the event.

If you want to send after the event has been acked I would expect this code to
be in OnEventAck (and you'll have to deal with the client we're waiting on going
away).

[James Cook, 2016/04/22 18:22:54]

This code is gone.

+
   event_dispatcher_.ProcessEvent(event);
 }
 
 void WindowManagerState::OnEventAck(mojom::WindowTree* tree,
                                     mojom::EventResult result) {
   if (tree_awaiting_input_ack_ != tree) {
     // TODO(sad): The ack must have arrived after the timeout. We should do
     // something here, and in OnEventAckTimeout().
     return;
   }
@@ skipping 28 matching lines @@
 void WindowManagerState::ProcessNextEventFromQueue() {
   // Loop through |event_queue_| stopping after dispatching the first valid
   // event.
   while (!event_queue_.empty()) {
     scoped_ptr<QueuedEvent> queued_event = std::move(event_queue_.front());
     event_queue_.pop();
     if (!queued_event->processed_target) {
       event_dispatcher_.ProcessEvent(*queued_event->event);
       return;
     }
+
+    // If the event has a target it was already sent to observers before its
+    // initial processing.
+    window_server()->SendToEventObservers(*queued_event->event);
+
     if (queued_event->processed_target->IsValid()) {
       DispatchInputEventToWindowImpl(
           queued_event->processed_target->window(),
           queued_event->processed_target->in_nonclient_area(),
           *queued_event->event, queued_event->processed_target->accelerator());
       return;
     }
   }
 }
 
@@ skipping 91 matching lines @@
 
   base::WeakPtr<Accelerator> weak_accelerator;
   if (accelerator)
     weak_accelerator = accelerator->GetWeakPtr();
   DispatchInputEventToWindowImpl(target, in_nonclient_area, event,
                                  weak_accelerator);
 }
 
 }  // namespace ws
 }  // namespace mus