Promotes remaining global window manager state into WindowManagerState

components/mus/ws/event_dispatcher.cc

 // Copyright 2015 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/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_finder.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
 namespace mus {
 namespace ws {
+
+using Entry = std::pair<uint32_t, std::unique_ptr<Accelerator>>;
+
 namespace {
 
 bool IsOnlyOneMouseButtonDown(int flags) {
   const uint32_t button_only_flags =
       flags & (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON |
                ui::EF_RIGHT_MOUSE_BUTTON);
   return button_only_flags == ui::EF_LEFT_MOUSE_BUTTON ||
          button_only_flags == ui::EF_MIDDLE_MOUSE_BUTTON ||
          button_only_flags == ui::EF_RIGHT_MOUSE_BUTTON;
 }
@@ skipping 25 matching lines @@
   NOTREACHED();
   return 0;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
-      root_(nullptr),
       capture_window_(nullptr),
       capture_window_client_id_(kInvalidClientId),
       modal_window_controller_(this),
       mouse_button_down_(false),
       mouse_cursor_source_window_(nullptr),
       mouse_cursor_in_non_client_area_(false) {}
 
 EventDispatcher::~EventDispatcher() {
   if (capture_window_) {
     UnobserveWindow(capture_window_);
@@ skipping 85 matching lines @@
 
   // Set the capture before changing native capture; otherwise, the callback
   // from native platform might try to set the capture again.
   bool had_capture_window = capture_window_ != nullptr;
   capture_window_ = window;
   capture_window_client_id_ = client_id;
 
   // Begin tracking the capture window if it is not yet being observed.
   if (window) {
     ObserveWindow(window);
+    // TODO(sky): this conditional is problematic for the case of capture moving
+    // to a different display.
     if (!had_capture_window)
-      delegate_->SetNativeCapture();
+      delegate_->SetNativeCapture(window);
   } else {
     delegate_->ReleaseNativeCapture();
     if (!mouse_button_down_)
       UpdateCursorProviderByLastKnownLocation();
   }
 
   return true;
 }
 
 void EventDispatcher::AddSystemModalWindow(ServerWindow* window) {
@@ skipping 15 matching lines @@
   if (!capture_window_)
     return;
 
   if (modal_window_controller_.IsWindowBlocked(capture_window_))
     SetCaptureWindow(nullptr, kInvalidClientId);
 }
 
 void EventDispatcher::UpdateNonClientAreaForCurrentWindow() {
   if (mouse_cursor_source_window_) {
     gfx::Point location = mouse_pointer_last_location_;
-    ServerWindow* target = FindDeepestVisibleWindowForEvents(root_, &location);
+    ServerWindow* target = FindDeepestVisibleWindowForEvents(&location);
     if (target == mouse_cursor_source_window_) {
       mouse_cursor_in_non_client_area_ =
           mouse_cursor_source_window_
               ? IsLocationInNonclientArea(mouse_cursor_source_window_, location)
               : false;
     }
   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
-    mouse_cursor_source_window_ =
-        FindDeepestVisibleWindowForEvents(root_, &location);
+    mouse_cursor_source_window_ = FindDeepestVisibleWindowForEvents(&location);
 
     mouse_cursor_in_non_client_area_ =
         mouse_cursor_source_window_
             ? IsLocationInNonclientArea(mouse_cursor_source_window_, location)
             : false;
   }
 }
 
 bool EventDispatcher::AddAccelerator(uint32_t id,
                                      mojom::EventMatcherPtr event_matcher) {
   std::unique_ptr<Accelerator> accelerator(new Accelerator(id, *event_matcher));
   // If an accelerator with the same id or matcher already exists, then abort.
   for (const auto& pair : accelerators_) {
     if (pair.first == id || accelerator->EqualEventMatcher(pair.second.get()))
       return false;
   }
   accelerators_.insert(Entry(id, std::move(accelerator)));
   return true;
 }
 
 void EventDispatcher::RemoveAccelerator(uint32_t id) {
   auto it = accelerators_.find(id);
   // Clients may pass bogus ids.
   if (it != accelerators_.end())
     accelerators_.erase(it);
 }
 
 void EventDispatcher::ProcessEvent(const ui::Event& event) {
-  if (!root_)  // Tests may not have a root window.
-    return;
-
   if (event.IsKeyEvent()) {
     const ui::KeyEvent* key_event = event.AsKeyEvent();
     if (event.type() == ui::ET_KEY_PRESSED && !key_event->is_char()) {
       Accelerator* pre_target =
           FindAccelerator(*key_event, ui::mojom::AcceleratorPhase::PRE_TARGET);
       if (pre_target) {
         delegate_->OnAccelerator(pre_target->id(), event);
         return;
       }
     }
@@ skipping 66 matching lines @@
     UpdateTargetForPointer(pointer_id, event);
     if (is_mouse_event)
       mouse_cursor_source_window_ = pointer_targets_[pointer_id].window;
 
     PointerTarget& pointer_target = pointer_targets_[pointer_id];
     if (pointer_target.is_pointer_down) {
       if (is_mouse_event)
         mouse_cursor_source_window_ = pointer_target.window;
       if (!any_pointers_down) {
         delegate_->SetFocusedWindowFromEventDispatcher(pointer_target.window);
-        delegate_->SetNativeCapture();
+        delegate_->SetNativeCapture(pointer_target.window);
       }
     }
   }
 
   // When we release the mouse button, we want the cursor to be sourced from
   // the window under the mouse pointer, even though we're sending the button
   // up event to the window that had implicit capture. We have to set this
   // before we perform dispatch because the Delegate is going to read this
   // information from us.
   if (is_pointer_going_up && is_mouse_event)
@@ skipping 55 matching lines @@
     DispatchToPointerTarget(pointer_targets_[pointer_id], exit_event);
   }
 
   // Technically we're updating in place, but calling start then stop makes for
   // simpler code.
   StopTrackingPointer(pointer_id);
   StartTrackingPointer(pointer_id, pointer_target);
 }
 
 EventDispatcher::PointerTarget EventDispatcher::PointerTargetForEvent(
-    const ui::LocatedEvent& event) const {
+    const ui::LocatedEvent& event) {
   PointerTarget pointer_target;
   gfx::Point location(event.location());
-  ServerWindow* target_window =
-      FindDeepestVisibleWindowForEvents(root_, &location);
+  ServerWindow* target_window = FindDeepestVisibleWindowForEvents(&location);
   pointer_target.window =
       modal_window_controller_.GetTargetForWindow(target_window);
   pointer_target.is_mouse_event = event.IsMousePointerEvent();
   pointer_target.in_nonclient_area =
       target_window != pointer_target.window ||
       IsLocationInNonclientArea(pointer_target.window, location);
   pointer_target.is_pointer_down = event.type() == ui::ET_POINTER_DOWN;
   return pointer_target;
 }
 
@@ skipping 78 matching lines @@
     const ui::KeyEvent& event,
     const ui::mojom::AcceleratorPhase phase) {
   for (const auto& pair : accelerators_) {
     if (pair.second->MatchesEvent(event, phase)) {
       return pair.second.get();
     }
   }
   return nullptr;
 }
 
+ServerWindow* EventDispatcher::FindDeepestVisibleWindowForEvents(
+    gfx::Point* location) {
+  ServerWindow* root = delegate_->GetRootWindowContaining(*location);
+  if (!root)
+    return nullptr;
+
+  return mus::ws::FindDeepestVisibleWindowForEvents(root, location);
+}
+
 void EventDispatcher::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                   ServerWindow* new_parent,
                                                   ServerWindow* old_parent) {
   // TODO(sky): moving to a different root likely needs to transfer capture.
   // TODO(sky): this isn't quite right, I think the logic should be (assuming
   // moving in same root and still drawn):
   // . if there is capture and window is still in the same root, continue
   //   sending to it.
   // . if there isn't capture, then reevaluate each of the pointer targets
   //   sending exit as necessary.
@@ skipping 10 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus