mus: Add EventObserver to allow passively listening to UI events

components/mus/public/interfaces/window_tree.mojom

 // 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.
 
 module mus.mojom;
 
 import "components/mus/public/interfaces/compositor_frame.mojom";
 import "components/mus/public/interfaces/cursor.mojom";
 import "components/mus/public/interfaces/input_events.mojom";
+import "components/mus/public/interfaces/input_event_matcher.mojom";
 import "components/mus/public/interfaces/mus_constants.mojom";
 import "components/mus/public/interfaces/surface_id.mojom";
 import "components/mus/public/interfaces/window_manager.mojom";
 import "components/mus/public/interfaces/window_manager_constants.mojom";
 import "ui/mojo/geometry/geometry.mojom";
 import "ui/mojo/ime/text_input_state.mojom";
 
 struct ViewportMetrics {
   mojo.Size size_in_pixels;
   // A value of 0 indicates the real value is not yet available.
@@ skipping 82 matching lines @@
   // current input events are canceled. The given window will receive all
   // subsequent input until an alternate window is set via SetCapture, or
   // ReleaseCapture is called for |window_id|. OnLostCapture is called to notify
   // of capture ending.
   SetCapture(uint32 change_id, uint32 window_id);
 
   // Releases input event capture for the given |window_id|. This does nothing
   // if |window_id| does not currently have capture.
   ReleaseCapture(uint32 change_id, uint32 window_id);
 
+  // Sets an observer that monitors all events, even if they are not targeted
+  // at a window in this tree. If an event matchs |matcher| the observer reports
+  // it to the WindowTreeClient via OnEventObserved(). Each client may only have
+  // one observer at a time. Set the matcher to null to clear the observer.
+  SetEventObserver(EventMatcher? matcher);
+
   // Sets the specified bounds of the specified window.
   SetWindowBounds(uint32 change_id, uint32 window_id, mojo.Rect bounds);
 
   // Sets the client area of the specified window. The client area is specified
   // by way of insets. Everything outside of the insets, and not in
   // |additional_client_areas| is considered non-client area.
   // TODO(sky): convert additional_client_areas to a path.
   SetClientArea(uint32 window_id,
                 mojo.Insets insets,
                 array<mojo.Rect>? additional_client_areas);
@@ skipping 229 matching lines @@
 
   // Invoked when a window property is changed. If this change is a removal,
   // |new_data| is null.
   OnWindowSharedPropertyChanged(uint32 window,
                                 string name,
                                 array<uint8>? new_data);
 
   // Invoked when an event is targeted at the specified window. The client must
   // call WindowTree::OnWindowInputEventAck() with the same |event_id| to notify
   // that the event has been processed, and with an EventResult value to notify
-  // if the event was consumed. The client will not receive farther events until
-  // the event is ack'ed.
-  OnWindowInputEvent(uint32 event_id, uint32 window, Event event);
+  // if the event was consumed. |matched_observer| is true if the event also
+  // matched the active event observer for this client. The client will not
+  // receive farther events until the event is ack'ed.
+  OnWindowInputEvent(uint32 event_id,
+                     uint32 window,
+                     Event event,
+                     bool matched_observer);

[sky, 2016/04/22 20:18:48]

Rather than a bool for matched_observer I think you should use an id. If you
don't use an id it means the client doesn't have a way to ensure they know which
eventmatcher matched. For example. Lets say the client has an EventMatcher
installed and wants to replace it with a new one. If there was an in flight
event that only matched the first eventmatcher the client will send it to the
wrong place.

I recommend having SetEventObserver take a client assigned int it that is passed
through OnWindowInputEvent.

[James Cook, 2016/04/22 21:25:08]

Done.

+
+  // Invoked when an event is sent via the EventObserver and not targeted at a
+  // specific window. The client does not need to acknowledge these events.

[sky, 2016/04/22 20:18:48]

'does not need to' -> should not

[James Cook, 2016/04/22 21:25:08]

Done.

+  OnEventObserved(Event event);
 
   // Called in two distinct cases: when a window known to the connection gains
   // focus, or when focus moves from a window known to the connection to a
   // window not known to the connection. In the later case |focused_window_id|
   // is 0. As with other functions this is only called if the client did not
   // initiate the change.
   OnWindowFocused(uint32 focused_window_id);
 
   OnWindowPredefinedCursorChanged(uint32 window_id, Cursor cursor_id);
 
   // A change initiated from the client has completed. See description of
   // change ids for details.
   OnChangeCompleted(uint32 change_id, bool success);
 
   // The WindowManager is requesting the specified window to close. If the
   // client allows the change it should delete the window.
   RequestClose(uint32 window_id);
 
   // See description of WindowManager for details.
   GetWindowManager(associated WindowManager& internal);
 };
 
 // Mus provides this interface as a way for clients to connect and obtain a
 // WindowTree handle with a supplied WindowTreeClient handle. The
 // WindowTreeClient has no roots, use NewTopLevelWindow() to create one.
 interface WindowTreeFactory {
   CreateWindowTree(WindowTree& tree_request, WindowTreeClient client);
 };