mus: Allow embedder to intercept events.

components/mus/ws/window_manager_state.cc

 // Copyright 2016 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.
 
 #include "components/mus/ws/window_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/common/event_matcher_util.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display_manager.h"
@@ skipping 36 matching lines @@
 }
 
 std::unique_ptr<ui::Event> CoalesceEvents(std::unique_ptr<ui::Event> first,
                                           std::unique_ptr<ui::Event> second) {
   DCHECK(first->type() == ui::ET_POINTER_MOVED)
       << " Non-move events cannot be merged yet.";
   // For mouse moves, the new event just replaces the old event.
   return second;
 }
 
+const ServerWindow* GetEmbedRoot(const ServerWindow* window) {
+  DCHECK(window);
+  const ServerWindow* embed_root = window->parent();
+  while (embed_root && embed_root->id().client_id == window->id().client_id)
+    embed_root = embed_root->parent();
+  return embed_root;
+}
+
 }  // namespace
 
 class WindowManagerState::ProcessedEventTarget {
  public:
   ProcessedEventTarget(ServerWindow* window,
                        ClientSpecificId client_id,
                        Accelerator* accelerator)
       : client_id_(client_id) {
     tracker_.Add(window);
     if (accelerator)
@@ skipping 354 matching lines @@
 
   base::WeakPtr<Accelerator> weak_accelerator;
   if (accelerator)
     weak_accelerator = accelerator->GetWeakPtr();
   DispatchInputEventToWindowImpl(target, client_id, event, weak_accelerator);
 }
 
 ClientSpecificId WindowManagerState::GetEventTargetClientId(
     const ServerWindow* window,
     bool in_nonclient_area) {
-  WindowTree* tree =
-      in_nonclient_area ? window_server()->GetTreeWithId(window->id().client_id)
-                        : window_server()->GetTreeWithRoot(window);
+  // If the event is in the non-client area the event goes to the owner of
+  // the window.
+  WindowTree* tree = nullptr;
+  if (in_nonclient_area) {
+    tree = window_server()->GetTreeWithId(window->id().client_id);
+  } else {
+    // If the window is an embed root, forward to the embedded window.
+    tree = window_server()->GetTreeWithRoot(window);
+    if (!tree)
+      tree = window_server()->GetTreeWithId(window->id().client_id);
+  }
+
+  const ServerWindow* embed_root =
+      tree->HasRoot(window) ? window : GetEmbedRoot(window);
+  while (tree && tree->embedder_intercepts_events()) {
+    DCHECK(tree->HasRoot(embed_root));
+    tree = window_server()->GetTreeWithId(embed_root->id().client_id);
+    embed_root = GetEmbedRoot(embed_root);
+  }
+
   if (!tree) {
-    if (in_nonclient_area) {
-      // Being the root of the tree means we may get events outside the bounds
-      // of the platform window. Because the root has a client id of 0,
-      // no WindowTree is found for it and we have to special case it here.
-      tree = window_tree_;
-    } else {
-      tree = window_server()->GetTreeWithId(window->id().client_id);
-    }
+    DCHECK(in_nonclient_area);
+    tree = window_tree_;
   }
   return tree->id();
 }
 
 ServerWindow* WindowManagerState::GetRootWindowContaining(
     const gfx::Point& location) {
   if (display_manager()->displays().empty())
     return nullptr;
 
   // TODO(sky): this isn't right. To correctly implement need bounds of
   // Display, which we aren't tracking yet. For now, use the first display.
   Display* display = *(display_manager()->displays().begin());
   WindowManagerDisplayRoot* display_root =
       display->GetWindowManagerDisplayRootForUser(user_id());
   return display_root ? display_root->root() : nullptr;
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToEventObservers(event, user_id(),
                                         nullptr /* ignore_tree */);
 }
 
 }  // namespace ws
 }  // namespace mus