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 <queue>
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/common/event_matcher_util.h"
@@ skipping 37 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;
 }
 
+ServerWindow* GetEmbedRoot(ServerWindow* window) {
+  DCHECK(window);
+  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,
                        bool in_nonclient_area,
                        Accelerator* accelerator)
       : in_nonclient_area_(in_nonclient_area) {
     tracker_.Add(window);
     if (accelerator)
@@ skipping 222 matching lines @@
 
   if (event.IsMousePointerEvent()) {
     DCHECK(event_dispatcher_.mouse_cursor_source_window());
 
     int32_t cursor_id = 0;
     if (event_dispatcher_.GetCurrentMouseCursor(&cursor_id))
       display_->UpdateNativeCursor(cursor_id);
   }
 
   // If the event is in the non-client area the event goes to the owner of
-  // the window. Otherwise if the window is an embed root, forward to the
-  // embedded window.
-  WindowTree* tree =
-      in_nonclient_area
-          ? window_server()->GetTreeWithId(target->id().client_id)
-          : window_server()->GetTreeWithRoot(target);
+  // the window.
+  WindowTree* tree = nullptr;
+  if (in_nonclient_area) {
+    tree = window_server()->GetTreeWithId(target->id().client_id);
+  } else {
+    // If the window is an embed root, forward to the embedded window.
+    tree = window_server()->GetTreeWithRoot(target);
+    if (!tree)
+      tree = window_server()->GetTreeWithId(target->id().client_id);
+  }
+
+  ServerWindow* embed_root =
+      tree->HasRoot(target) ? target : GetEmbedRoot(target);
+  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.
-      DCHECK_EQ(target, root_.get());
-      tree = tree_;
-    } else {
-      tree = window_server()->GetTreeWithId(target->id().client_id);
-    }
+    DCHECK(in_nonclient_area);
+    DCHECK_EQ(target, root_.get());
+    tree = tree_;
   }
 
   // TOOD(sad): Adjust this delay, possibly make this dynamic.
   const base::TimeDelta max_delay = base::debug::BeingDebugged()
                                         ? base::TimeDelta::FromDays(1)
                                         : GetDefaultAckTimerDelay();
   event_ack_timer_.Start(
       FROM_HERE, max_delay,
       base::Bind(&WindowManagerState::OnEventAckTimeout,
                  weak_factory_.GetWeakPtr(), tree->id()));
@@ skipping 94 matching lines @@
                                  weak_accelerator);
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToEventObservers(event, user_id_,
                                         nullptr /* ignore_tree */);
 }
 
 }  // namespace ws
 }  // namespace mus