mus: Add watcher for all touch events.

services/ui/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 ui.mojom;
 
 import "cc/ipc/surface_id.mojom";
 import "services/ui/public/interfaces/cursor.mojom";
 import "services/ui/public/interfaces/event_matcher.mojom";
 import "services/ui/public/interfaces/mus_constants.mojom";
@@ skipping 54 matching lines @@
 
   // 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 OnWindowInputEvent (if the event target is
   // this window tree) or OnEventObserved (if the target is another tree). The
   // client must supply a non-zero |observer_id|, which is reported back with
-  // observed events.  Set the matcher to null to clear the observer.
-  SetEventObserver(EventMatcher? matcher, uint32 observer_id);
+  // observed events.
+  AddEventObserver(EventMatcher? matcher, uint32 observer_id);

[sky, 2016/07/08 15:41:11]

In thinking about this a bit could we we implement > 1 matchers in the client
library? The client library would maintain the set of matchers and build a
matcher that matches all the supplied matchers. This way we minimize interaction
with the window server and keep the complexity in the client. Is that possible?

[sadrul, 2016/07/08 15:51:30]

I think this would be possible (and how I was thinking initially as well). But
it's not clear if we are going to need this. The touch-hud is going to be a
separate app, and it would need just the TouchEventWatcher. ash currently needs
just PointerWatcher. For some accessibility features (which I think should be a
separate app), we are going to need some event-watcher that match all touch and
mouse events. So with the use-cases we have right now, every client needs just
one type of watcher. So it would make sense to not introduce this yet, either on
the client or the server side, until we have a use-case where the client needs
more than one type of watcher. Maybe just leave a TODO for now?

[riajiang, 2016/07/11 20:13:22]

Changed back to support only one event matcher with TODOs and DCHECKs.

+
+  // Remove the event observer of the window tree with the observer_id.
+  RemoveEventObserver(uint32 observer_id);
 
   // Sets the specified bounds of the specified window.
   SetWindowBounds(uint32 change_id, uint32 window_id, gfx.mojom.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,
                 gfx.mojom.Insets insets,
@@ skipping 259 matching lines @@
 
   // 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. |event_observer_id| is non-zero 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,
                      ui.mojom.Event event,
-                     uint32 event_observer_id);
+                     array<uint32> event_observer_id);
 
   // Invoked when an |event| is sent via the EventObserver and not targeted at a
   // specific window. The |event_observer_id| is the one supplied to
   // SetEventObserver. The client should not acknowledge these events.
-  OnEventObserved(ui.mojom.Event event, uint32 event_observer_id);
+  OnEventObserved(ui.mojom.Event event, array<uint32> event_observer_id);
 
   // 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);
 };