mus: Allow embedder to intercept 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 "cc/ipc/surface_id.mojom";
 import "components/mus/public/interfaces/compositor_frame.mojom";
 import "components/mus/public/interfaces/cursor.mojom";
 import "components/mus/public/interfaces/event_matcher.mojom";
@@ skipping 34 matching lines @@
   // in the Window than the owner may also render to this surface as well.
   DEFAULT,
 };
 
 // The result of an input event sent to a client app.
 enum EventResult {
   HANDLED,
   UNHANDLED,
 };
 
+const uint32 kEmbedFlagEmbedderInterceptsEvents = 0x01;

[Ben Goodger (Google), 2016/06/16 16:53:49]

1. Can you use an enum for this, and refer to it from Embed() below?
2. You need to document the precise behavior of this flag. Does the child
receive the event too? If not, is the embedder required to forward it? etc etc.

[sadrul, 2016/06/16 16:56:59]

I had an enum before, but switched to using ints since it looks like that's how
flags are done in mojo (e.g. ui::EventFlag equivalents in mojom as kEventFlag*)

+
 // Windows are identified by a uint32. The upper 16 bits are the connection id,
 // and the lower 16 the id assigned by the client.
 //
 // 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
@@ skipping 156 matching lines @@
   // A window may only have one embedding in it at a time. Subsequent calls to
   // Embed() for the same window result in the currently embedded
   // WindowTreeClient being removed. The embedded app is told this by way of
   // OnUnembed(), which is followed by OnWindowDeleted() (as the connection no
   // longer has access to the window).
   //
   // The embedder can detect when the embedded app disconnects by way of
   // OnEmbeddedAppDisconnected().
   //
   // The callback returns whether the embedding was successful.
-  Embed(uint32 window_id, WindowTreeClient client) => (bool success);
+  Embed(uint32 window_id, WindowTreeClient client, uint32 flags)
+      => (bool success);
 
   // Sets focus to the specified window, use 0 to clear focus. For a window to
   // get focus the following has to happen: the window is drawn, the window has
   // been marked as focusable (see SetCanFocus()) and the window is in a
   // container the WindowManager has identified as allowing activation
   // (see WindowManagerClient::AddActivationParent()).
   SetFocus(uint32 change_id, uint32 window_id);
 
   // Marks the specified window as being able to receive focus.
   SetCanFocus(uint32 window_id, bool can_focus);
@@ skipping 159 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);
 };