mus: Change PointerWatcher to observe all pointer events, with moves optional.

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 14 matching lines @@
 // WindowTree completes processing of a function WindowTree calls
 // WindowTreeClient::OnChangeCompleted() with the change_id supplied by the
 // client and the result of the function. This allows the client to track
 // whether the call succeeded or not. Calls are done via the client interface
 // rather than a callback to ensure ordering. The server does not interpret the
 // change id in anyway, it is up to the client to assign a value and use it.
 // Generally the change id is an ever increasing integer.
 //
 // Event processing happens in the following order:
 // . The event is sent to the accelerator registered for the PRE_TARGET. If
-//   the client consumes the event, matching event observers are notified and
+//   the client consumes the event, matching pointer watchers are notified and
 //   processing stops. If the client does not consume the event processing
 //   continues.
 // . Target window (lookup of the target window depends upon the event type) and
-//   matching event observers are notified at the same time. The target is only
-//   notified once, even if it has a matching event observer registered. If the
+//   matching pointer watchers are notified at the same time. The target is only
+//   notified once, even if it has a matching pointer watcher registered. If the
 //   target consumes the event, processing stops.
 // . Accelerator registered for POST_TARGET. No response is expected from the
 //   client for the POST_TARGET and processing of the next continues
 //   immediately.
 interface WindowTree {
   // Creates a new window with the specified id. It is up to the client to
   // ensure the id is unique to the connection (the id need not be globally
   // unique). Additionally the connection id (embedded in |window_id|) must
   // match that of the connection.
   // Errors:
@@ skipping 22 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 OnWindowInputEvent (if the event target is
-  // this window tree) or OnEventObserved (if the target is another tree). The
+  // Starts the pointer watcher that monitors all events (including move events

[sky, 2016/08/04 20:40:26]

'all events' -> 'pointer events' right? Also, explicitly say what pointer events
this includes as it isn't everything, for example, it doesn't include
enter/exit.

[riajiang, 2016/08/04 21:22:06]

Changed to "pointer events". 
But I thought we would send all of move/enter/exit if want_moves==true?

[sky, 2016/08/04 23:08:44]

Consider if you did send the exit/enter and the client doesn't know about the
window. It means the client gets an exit/enter and they don't have a clue what
the window was. We should only send enter/exit if the client knows about the
window, otherwise they should get a move.

[James Cook, 2016/08/05 16:26:45]

sky@, what do you think about having PointerWatchers never send enter/exit? (Or
was that what you were suggesting before?) Clients should already get enter/exit
on windows they know about via normal event dispatch.

Ria, this was an oversight on my part, apologies.

[riajiang, 2016/08/05 17:36:02]

Okay I see. Done.

[riajiang, 2016/08/05 17:36:03]

No worries. Changed it to not match enter/exit. Didn't make any changes to
PointerWatcher for now.

+  // if |want_moves| is true), even if they are not targeted at a window in this
+  // tree. If an event matches the pointer watcher the observer reports it to

[sky, 2016/08/04 20:40:26]

'matches the pointer watcher' ? There is no pointer watcher. I think you want
something like, 'For pointer events that would normally be sent to the
requesting client OnWindowInputEvent() is called, all other matching pointer
events result in OnPointerEventObserved().'

Also, you should document that there is only ever one pointer watcher active at
a given time.

[riajiang, 2016/08/05 17:36:03]

Done and done.

+  // the WindowTreeClient via OnWindowInputEvent (if the event target is this
+  // window tree) or OnPointerEventObserved (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.
+  // observed events. The client should prefer |want_moves| to be false, as
+  // there's a system-wide performance/battery penalty for listening to moves.
   //
   // See class description for details on event delivery.
-  SetEventObserver(EventMatcher? matcher, uint32 observer_id);
+  StartPointerWatcher(bool want_moves, uint32 observer_id);
+
+  // Stops the pointer watcher for all events.
+  StopPointerWatcher();
 
   // 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 257 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. |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.
+  // if the event was consumed. |pointer_watcher_id| is non-zero if the event
+  // also matched the active pointer watcher for this client. The client will

[sky, 2016/08/04 20:40:26]

Again, there is no pointer watcher (at least from the perspective of the
client). I think you want something like, '|pointer_watcher_id| is the id
supplied to StartPointerWatcher() if the event is a pointer event and the client
called StartPointerWatcher().

[riajiang, 2016/08/05 17:36:03]

Done.

+  // not receive farther events until the event is ack'ed.
   OnWindowInputEvent(uint32 event_id,
                      uint32 window,
                      ui.mojom.Event event,
-                     uint32 event_observer_id);
+                     uint32 pointer_watcher_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);
+  // Invoked when an |event| is sent via the PointerWatcher and not targeted at

[sky, 2016/08/04 20:40:26]

There is no PointerWatcher in this code. I think you want something like:
'Called when a pointer event that would not normally be targeted at this client
is encountered and the client called StartPointerWatcher(). See
StartPointerWatcher() for details.'

[riajiang, 2016/08/05 17:36:03]

Done.

+  // a specific window. The |pointer_watcher_id| is the one supplied to
+  // StartPointerWatcher. The client should not acknowledge these events.
+  OnPointerEventObserved(ui.mojom.Event event, uint32 pointer_watcher_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);
 };