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,
 };
 
+// When this flag is set in a call to Embed(), the embedder (i.e. the client
+// that is making the call to Embed()) will receive events that are targeted to
+// the embedded client. The embedded client will not receive any input events
+// from the window server. However, the embedder can choose to dispatch events
+// to the embedded client through other mechanism.

[Ben Goodger (Google), 2016/06/16 17:34:36]

What other mechanism?

[sadrul, 2016/06/16 17:45:16]

In the case of chrome, the browser has another IPC channel to the renderer, and
it would use that channel for sending the events to the renderer. i.e. mus does
not provide a mechanism for the embedder to directly dispatch events to the
embedded client. The embedder/embeddee need to have a separate mechanism that
they decide on.

+const uint32 kEmbedFlagEmbedderInterceptsEvents = 0x01;
+
 // 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 141 matching lines @@
 
   // A connection may grant access to another connection by way of Embed().
   // Embed() results in the supplied WindowTreeClient being configured with a
   // root window of |window_id|. The supplied WindowTreeClient may create child
   // windows and do other various tree operations (including Embed()), but does
   // not see nor have access to any of the windows above the embed point.
   //
   // The caller must have created |window_id|. If not the request fails and the
   // response is false.
   //
+  // The embedder can dictate the behaviour of the embedded client by setting
+  // the appropriate embed flags (e.g. kEmbedFlagEmbedderInterceptsEvents).
+  //
   // When a connection embeds a WindowTreeClient the originating connection no
   // longer has privileges to access or see any of the children of the window.
   // If the window had existing children the children are removed. The
   // WindowManager gets to see the whole tree.
   //
   // 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 embed_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);
 };