Adds ability for pre-target accelerators to not consume 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 11 matching lines @@
 // The root window is identified with a connection id of 0, and value of 1.
 //
 // Most functions to the WindowTree take a change_id parameter. When
 // 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
+//   processing stops. If the EventMatcher does not consume the event processing

[sadrul, 2016/07/07 20:04:42]

Do you mean 'If the accelerator handler does not consume the event ...'?

[sky, 2016/07/07 21:55:42]

I changed it to client as that is what I said on the previous line.

+//   continues.
+// . Target window (lookup of the target window depends upon the event type) and
+//   matching event observers and notified at the same time. The target is only

[sadrul, 2016/07/07 20:04:42]

s/and/are

[sky, 2016/07/07 21:55:43]

Done.

+//   notified once, even if it has a matching event observer registered. If the
+//   target consumes the event, processing stops.

[sadrul, 2016/07/07 20:04:41]

What happens if there is a non-accelerator event for the target, but the
accelerator is yet to be acked by the window manager?

[sky, 2016/07/07 21:55:42]

Not sure what you mean. If there is no-accelerator than we aren't blocked
waiting for the wm. OTOH if there is an accelerator then step 1 waits until we
get the ack from the wm. Maybe I'm misunderstanding your question?

+// . 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:
   //   ERROR_CODE_VALUE_IN_USE: a window already exists with the specified id.
   //   ERROR_CODE_ILLEGAL_ARGUMENT: The connection part of |window_id| does not
   //     match the connection id of the client.
   NewWindow(uint32 change_id,
@@ skipping 24 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.
+  //
+  // See class description for details on event delivery.
   SetEventObserver(EventMatcher? matcher, 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,
@@ skipping 294 matching lines @@
   // 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);
 };