Separate out event-targeting logic in EventDispatcher to EventTargeter.

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/memory/ptr_util.h"
 #include "base/time/time.h"
@@ skipping 28 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       capture_window_(nullptr),
       capture_window_client_id_(kInvalidClientId),
       modal_window_controller_(this),
+      event_targeter_(
+          base::MakeUnique<EventTargeter>(delegate_,
+                                          &modal_window_controller_)),
       mouse_button_down_(false),
       mouse_cursor_source_window_(nullptr),
       mouse_cursor_in_non_client_area_(false) {}
 
 EventDispatcher::~EventDispatcher() {
   SetMouseCursorSourceWindow(nullptr);
   if (capture_window_) {
     UnobserveWindow(capture_window_);
     capture_window_ = nullptr;
     capture_window_client_id_ = kInvalidClientId;
@@ skipping 155 matching lines @@
   const ClientSpecificId target_client_id = delegate_->GetEventTargetClientId(
       mouse_cursor_source_window_, mouse_cursor_in_non_client_area_);
   const ServerWindow* window = mouse_cursor_source_window_;
   while (window && window->id().client_id == target_client_id)
     window = window->parent();
   return window;
 }
 
 void EventDispatcher::UpdateNonClientAreaForCurrentWindow() {
   if (mouse_cursor_source_window_) {
-    DeepestWindow deepest_window = FindDeepestVisibleWindowForEvents(
-        &mouse_pointer_last_location_, &mouse_pointer_display_id_);
+    DeepestWindow deepest_window =
+        event_targeter_->FindDeepestVisibleWindowForEvents(
+            &mouse_pointer_last_location_, &mouse_pointer_display_id_);
     if (deepest_window.window == mouse_cursor_source_window_) {
       mouse_cursor_in_non_client_area_ = mouse_cursor_source_window_
                                              ? deepest_window.in_non_client_area
                                              : false;
     }
   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
-    DeepestWindow deepest_window = FindDeepestVisibleWindowForEvents(
-        &mouse_pointer_last_location_, &mouse_pointer_display_id_);
+    DeepestWindow deepest_window =
+        event_targeter_->FindDeepestVisibleWindowForEvents(
+            &mouse_pointer_last_location_, &mouse_pointer_display_id_);
     SetMouseCursorSourceWindow(deepest_window.window);
     if (mouse_cursor_source_window_) {
       mouse_cursor_in_non_client_area_ = deepest_window.in_non_client_area;
     } else {
       SetMouseCursorSourceWindow(delegate_->GetRootWindowContaining(
           &mouse_pointer_last_location_, &mouse_pointer_display_id_));
       mouse_cursor_in_non_client_area_ = true;
     }
   }
 }
@@ skipping 121 matching lines @@
 
   // Update mouse down state upon events which change it.
   if (is_mouse_event) {
     if (event.type() == ui::ET_POINTER_DOWN)
       mouse_button_down_ = true;
     else if (is_pointer_going_up)
       mouse_button_down_ = false;
   }
 
   if (drag_controller_) {
-    const PointerTarget target = PointerTargetForEvent(event);
+    const PointerTarget target =
+        event_targeter_->PointerTargetForEvent(event, &event_display_id_);
     if (drag_controller_->DispatchPointerEvent(event, target.window))
       return;
   }
 
   if (capture_window_) {
     SetMouseCursorSourceWindow(capture_window_);
     DispatchToClient(capture_window_, capture_window_client_id_, event);
     return;
   }
 
@@ skipping 57 matching lines @@
   DCHECK(IsTrackingPointer(pointer_id));
   ServerWindow* window = pointer_targets_[pointer_id].window;
   pointer_targets_.erase(pointer_id);
   if (window)
     UnobserveWindow(window);
 }
 
 void EventDispatcher::UpdateTargetForPointer(int32_t pointer_id,
                                              const ui::LocatedEvent& event) {
   if (!IsTrackingPointer(pointer_id)) {
-    StartTrackingPointer(pointer_id, PointerTargetForEvent(event));
+    StartTrackingPointer(pointer_id, event_targeter_->PointerTargetForEvent(
+                                         event, &event_display_id_));
     return;
   }
 
-  const PointerTarget pointer_target = PointerTargetForEvent(event);
+  const PointerTarget pointer_target =
+      event_targeter_->PointerTargetForEvent(event, &event_display_id_);
   if (pointer_target.window == pointer_targets_[pointer_id].window &&
       pointer_target.in_nonclient_area ==
           pointer_targets_[pointer_id].in_nonclient_area) {
     // The targets are the same, only set the down state to true if necessary.
     // Down going to up is handled by ProcessLocatedEvent().
     if (pointer_target.is_pointer_down)
       pointer_targets_[pointer_id].is_pointer_down = true;
     return;
   }
 
   // The targets are changing. Send an exit if appropriate.
   if (event.IsMousePointerEvent()) {
     ui::PointerEvent exit_event(
         ui::ET_POINTER_EXITED, event.location(), event.root_location(),
         event.flags(), 0 /* changed_button_flags */,
         ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE,
                            ui::MouseEvent::kMousePointerId),
         event.time_stamp());
     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) {
-  PointerTarget pointer_target;
-  gfx::Point event_root_location(event.root_location());
-  DeepestWindow deepest_window = FindDeepestVisibleWindowForEvents(
-      &event_root_location, &event_display_id_);
-  pointer_target.window =
-      modal_window_controller_.GetTargetForWindow(deepest_window.window);
-  pointer_target.is_mouse_event = event.IsMousePointerEvent();
-  pointer_target.in_nonclient_area =
-      deepest_window.window != pointer_target.window ||
-      !pointer_target.window || deepest_window.in_non_client_area;
-  pointer_target.is_pointer_down = event.type() == ui::ET_POINTER_DOWN;
-  return pointer_target;
-}
-
 bool EventDispatcher::AreAnyPointersDown() const {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.is_pointer_down)
       return true;
   }
   return false;
 }
 
 void EventDispatcher::DispatchToPointerTarget(const PointerTarget& target,
                                               const ui::LocatedEvent& event) {
@@ skipping 68 matching lines @@
 Accelerator* EventDispatcher::FindAccelerator(
     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;
 }
 
-DeepestWindow EventDispatcher::FindDeepestVisibleWindowForEvents(
-    gfx::Point* location,
-    int64_t* display_id) {
-  ServerWindow* root = delegate_->GetRootWindowContaining(location, display_id);
-  return root ? ui::ws::FindDeepestVisibleWindowForEvents(root, *location)
-              : DeepestWindow();
-}
-
 void EventDispatcher::CancelImplicitCaptureExcept(ServerWindow* window,
                                                   ClientSpecificId client_id) {
   for (const auto& pair : pointer_targets_) {
     ServerWindow* target = pair.second.window;
     if (!target)
       continue;
     UnobserveWindow(target);
     if (target == window)
       continue;
 
@@ skipping 50 matching lines @@
   if (mouse_cursor_source_window_ == window)
     SetMouseCursorSourceWindow(nullptr);
 }
 
 void EventDispatcher::OnDragCursorUpdated() {
   delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 }  // namespace ws
 }  // namespace ui