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
-  // client must supply a non-zero |observer_id|, which is reported back with
-  // observed events.  Set the matcher to null to clear the observer.
+  // Starts the pointer watcher that monitors pointer events (monitor pointer

[sky, 2016/08/05 18:06:50]

How about changing the () to:
(up/down events if |wants_move| if false, up/down and move if |wants_move| is
true).

[riajiang, 2016/08/05 19:23:59]

Done.

+  // up/down events if |want_moves| is false and monitor pointer up/down/move
+  // events if |want_moves| is true), even if they are not targeted at a window
+  // in this tree. For pointer events that would normally be sent to the
+  // requesting client (if the event target is this window tree)
+  // OnWindowInputEvent() is called, all other matching pointer events (if the
+  // target is another tree) result in OnPointerEventObserved(). The client must
+  // supply a non-zero |pointer_watcher_id|, which is reported back with matched
+  // events. There is only ever one pointer watcher active at a given time. 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 pointer_watcher_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 the id supplied to
+  // StartPointerWatcher() if the event is a pointer event and the client called
+  // StartPointerWatcher(). 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);
+                     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);
+  // Called when a pointer event that would not normally be targeted at this
+  // client is encountered and the client called StartPointerWatcher(). The
+  // |pointer_watcher_id| is the one supplied to StartPointerWatcher(). See
+  // StartPointerWatcher() for details.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);
 };