Find display root ServerWindow for located events in mus.

services/ui/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 "services/ui/ws/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "services/ui/ws/accelerator.h"
@@ skipping 302 matching lines @@
     delegate_->OnAccelerator(post_target->id(), event,
                              EventDispatcherDelegate::AcceleratorPhase::POST);
 }
 
 void EventDispatcher::ProcessLocatedEvent(const ui::LocatedEvent& event) {
   DCHECK(event.IsPointerEvent() || event.IsMouseWheelEvent());
   const bool is_mouse_event =
       event.IsMousePointerEvent() || event.IsMouseWheelEvent();
 
   if (is_mouse_event) {
-    mouse_pointer_last_location_ = event.location();
+    mouse_pointer_last_location_ = event.root_location();
     delegate_->OnMouseCursorLocationChanged(event.root_location());
   }
 
   // Release capture on pointer up. For mouse we only release if there are
   // no buttons down.
   const bool is_pointer_going_up =
       (event.type() == ui::ET_POINTER_UP ||
        event.type() == ui::ET_POINTER_CANCELLED) &&
       (!is_mouse_event || IsOnlyOneMouseButtonDown(event.flags()));
 
@@ skipping 96 matching lines @@
 
   // 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) {
   PointerTarget pointer_target;
-  gfx::Point location(event.location());
+  gfx::Point location(event.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 80 matching lines @@
     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);
+  ServerWindow* root = delegate_->GetRootWindowContaining(location);
   if (!root)
     return nullptr;
 
   return ui::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.
@@ skipping 16 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace ui