Make event-targeting asynchronous in window server.

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 65 matching lines @@
   while (!pointer_targets_.empty())
     StopTrackingPointer(pointer_targets_.begin()->first);
 
   mouse_button_down_ = false;
 }
 
 void EventDispatcher::SetMousePointerDisplayLocation(
     const gfx::Point& display_location,
     const int64_t display_id) {
   DCHECK(pointer_targets_.empty());
-  mouse_pointer_last_location_ = display_location;
-  mouse_pointer_display_id_ = display_id;
+  UpdateMousePointerLocation(display_location, display_id);
   UpdateCursorProviderByLastKnownLocation();
   // Write our initial location back to our shared screen coordinate. This
   // shouldn't cause problems because we already read the cursor before we
   // process any events in views during window construction.
   delegate_->OnMouseCursorLocationChanged(display_location, display_id);
 }
 
 ui::CursorData EventDispatcher::GetCurrentMouseCursor() const {
   if (drag_controller_)
     return drag_controller_->current_cursor();
@@ skipping 119 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 =
-        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;
-    }
+    event_targeter_->FindDeepestVisibleWindowForEvents(
+        mouse_pointer_last_location_, mouse_pointer_display_id_,
+        base::BindOnce(
+            &EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow,
+            base::Unretained(this)));
   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
-    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;
-    }
+    event_targeter_->FindDeepestVisibleWindowForEvents(
+        mouse_pointer_last_location_, mouse_pointer_display_id_,
+        base::BindOnce(&EventDispatcher::
+                           UpdateCursorProviderByLastKnownLocationOnFoundWindow,
+                       base::Unretained(this)));
   }
 }
 
 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) {
       DVLOG(1) << "duplicate accelerator. Accelerator id=" << accelerator->id()
@@ skipping 45 matching lines @@
             pre_target->id(), event_display_id_, event,
             EventDispatcherDelegate::AcceleratorPhase::PRE);
         return;
       }
     }
     ProcessKeyEvent(*key_event, match_phase);
     return;
   }
 
   DCHECK(event.IsPointerEvent());
-  ProcessPointerEvent(*event.AsPointerEvent());
-  return;
+  event_targeter_->PointerTargetForEvent(
+      *event.AsPointerEvent(), event_display_id_,
+      base::BindOnce(&EventDispatcher::ProcessPointerEventOnFoundTarget,
+                     base::Unretained(this), *event.AsPointerEvent()));
 }
 
 void EventDispatcher::SetMouseCursorSourceWindow(ServerWindow* window) {
   if (mouse_cursor_source_window_ == window)
     return;
 
   if (mouse_cursor_source_window_)
     UnobserveWindow(mouse_cursor_source_window_);
   mouse_cursor_source_window_ = window;
   if (mouse_cursor_source_window_)
     ObserveWindow(mouse_cursor_source_window_);
 }
 
+void EventDispatcher::UpdateMousePointerLocation(
+    const gfx::Point& new_mouse_location,
+    const int64_t new_mouse_display_id) {
+  mouse_pointer_last_location_ = new_mouse_location;
+  mouse_pointer_display_id_ = new_mouse_display_id;
+}
+
 void EventDispatcher::ProcessKeyEvent(const ui::KeyEvent& event,
                                       AcceleratorMatchPhase match_phase) {
   Accelerator* post_target =
       FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET);
   if (drag_controller_ && event.type() == ui::ET_KEY_PRESSED &&
       event.key_code() == ui::VKEY_ESCAPE) {
     drag_controller_->Cancel();
     return;
   }
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher(event_display_id_);
   if (focused_window) {
     // Assume key events are for the client area.
     const bool in_nonclient_area = false;
     const ClientSpecificId client_id =
         delegate_->GetEventTargetClientId(focused_window, in_nonclient_area);
     delegate_->DispatchInputEventToWindow(
         focused_window, client_id, event_display_id_, event, post_target);
     return;
   }
   delegate_->OnEventTargetNotFound(event, event_display_id_);
   if (post_target)
     delegate_->OnAccelerator(post_target->id(), event_display_id_, event,
                              EventDispatcherDelegate::AcceleratorPhase::POST);
 }
 
-void EventDispatcher::ProcessPointerEvent(const ui::PointerEvent& event) {
-  DCHECK(event.IsPointerEvent());
+void EventDispatcher::ProcessPointerEventOnFoundTarget(
+    const ui::PointerEvent& event,
+    const PointerTarget& pointer_target_found,
+    const DeepestWindow& deepest_window,
+    const gfx::Point& location_in_display,
+    const int64_t display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();
+
+  std::unique_ptr<ui::Event> cloned_event = ui::Event::Clone(event);
+  if (display_id != event_display_id_) {
+    event_display_id_ = display_id;
+    cloned_event->AsLocatedEvent()->set_root_location(location_in_display);
+  }
+
   const bool is_mouse_event = event.IsMousePointerEvent();
 
   if (is_mouse_event) {
-    mouse_pointer_last_location_ = event.root_location();
-    mouse_pointer_display_id_ = event_display_id_;
-    delegate_->OnMouseCursorLocationChanged(event.root_location(),
-                                            event_display_id_);
+    UpdateMousePointerLocation(location_in_display, display_id);
+    delegate_->OnMouseCursorLocationChanged(location_in_display, display_id);
   }
 
   // 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()));
 
   // 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 =
-        event_targeter_->PointerTargetForEvent(event, &event_display_id_);
-    if (drag_controller_->DispatchPointerEvent(event, target.window))
+    if (drag_controller_->DispatchPointerEvent(*cloned_event->AsPointerEvent(),
+                                               pointer_target_found.window))
       return;
   }
 
   if (capture_window_) {
     SetMouseCursorSourceWindow(capture_window_);
-    DispatchToClient(capture_window_, capture_window_client_id_, event);
+    DispatchToClient(capture_window_, capture_window_client_id_,
+                     *cloned_event->AsPointerEvent());
     return;
   }
 
   const int32_t pointer_id = event.pointer_details().id;
   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
     const bool any_pointers_down = AreAnyPointersDown();
-    UpdateTargetForPointer(pointer_id, event);
+    UpdateTargetForPointer(pointer_id, *cloned_event->AsPointerEvent(),
+                           pointer_target_found);
     if (is_mouse_event)
       SetMouseCursorSourceWindow(pointer_targets_[pointer_id].window);
 
     PointerTarget& pointer_target = pointer_targets_[pointer_id];
     if (pointer_target.is_pointer_down) {
       if (is_mouse_event)
         SetMouseCursorSourceWindow(pointer_target.window);
       if (!any_pointers_down) {
         if (pointer_target.window)
           delegate_->SetFocusedWindowFromEventDispatcher(pointer_target.window);
         ServerWindow* capture_window = pointer_target.window;
         if (!capture_window) {
-          gfx::Point event_location = event.root_location();
+          gfx::Point event_location =
+              cloned_event->AsPointerEvent()->root_location();
           int64_t event_display_id = event_display_id_;
           capture_window = delegate_->GetRootWindowContaining(
               &event_location, &event_display_id);
         }
         delegate_->SetNativeCapture(capture_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)
-    UpdateCursorProviderByLastKnownLocation();
+  if (is_pointer_going_up && is_mouse_event) {
+    UpdateCursorProviderByLastKnownLocationWithWindow(
+        deepest_window, location_in_display, display_id);
+  }
 
-  DispatchToPointerTarget(pointer_targets_[pointer_id], event);
+  DispatchToPointerTarget(pointer_targets_[pointer_id],
+                          *cloned_event->AsPointerEvent());
 
   if (is_pointer_going_up) {
     if (is_mouse_event)
       pointer_targets_[pointer_id].is_pointer_down = false;
     else
       StopTrackingPointer(pointer_id);
     if (!AreAnyPointersDown())
       delegate_->ReleaseNativeCapture();
   }
 }
 
+void EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+    const DeepestWindow& deepest_window,
+    const gfx::Point& location_in_display,
+    const int64_t display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();

[sky, 2017/06/02 21:17:51]

Because this code is now processed async, I think you need to propagate the
check for mouse_cursor_source_window_ here. By that I mean early out if
!mouse_cursor_source_window_.

[sky, 2017/06/02 21:17:51]

Why does this code need to call back to event_targeter_? Can't EventTargeter
take care of this? By that I mean EventTargeter would call the callback, and
then process the next event as appropriate.

[riajiang, 2017/06/02 22:56:17]

Yes! Done.

[riajiang, 2017/06/02 22:56:17]

I was thinking ui::ws::FindDeepestVisibleWindowForEvents used in the callback
run in EventTargeter::FindDeepestVisibleWindowForEventsAsync will be async when
it's changed to be calling Blink so we only know it's really done when these
functions in EventDispatcher are called. But Blink can call a callback back to
EventTargeter and then we can process the next event and deliver target back to
EventDispatcher. Moved to EventTargeter.

+
+  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;
+  }
+  UpdateMousePointerLocation(location_in_display, display_id);
+  delegate_->UpdateNativeCursorFromDispatcher();
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+    const DeepestWindow& deepest_window,
+    const gfx::Point& location_in_display,
+    const int64_t display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();
+  UpdateCursorProviderByLastKnownLocationWithWindow(
+      deepest_window, location_in_display, display_id);
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationWithWindow(

[sky, 2017/06/02 21:17:51]

It's not clear what 'WithWindow' means here. Maybe
UpdateCursorProviderByLastKnownLocationImpl?

[riajiang, 2017/06/02 22:56:17]

Since event_targeter_->ProcessNextHittesetRequestFromQueue(); is now deleted,
removed this function.

+    const DeepestWindow& deepest_window,
+    const gfx::Point& location_in_display,
+    const int64_t display_id) {
+  SetMouseCursorSourceWindow(deepest_window.window);

[sky, 2017/06/02 21:17:51]

Similar comment here about early out if mouse_button_down_.

[riajiang, 2017/06/02 22:56:16]

Done.

+  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;
+  }
+  UpdateMousePointerLocation(location_in_display, display_id);
+  delegate_->UpdateNativeCursorFromDispatcher();
+}
+
 void EventDispatcher::StartTrackingPointer(
     int32_t pointer_id,
     const PointerTarget& pointer_target) {
   DCHECK(!IsTrackingPointer(pointer_id));
   if (pointer_target.window)
     ObserveWindow(pointer_target.window);
   pointer_targets_[pointer_id] = pointer_target;
 }
 
 void EventDispatcher::StopTrackingPointer(int32_t pointer_id) {
   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) {
+void EventDispatcher::UpdateTargetForPointer(
+    int32_t pointer_id,
+    const ui::PointerEvent& event,
+    const PointerTarget& pointer_target_found) {

[sky, 2017/06/02 21:17:51]

pointer_target_found -> pointer_target

[riajiang, 2017/06/02 22:56:16]

Done.

   if (!IsTrackingPointer(pointer_id)) {
-    StartTrackingPointer(pointer_id, event_targeter_->PointerTargetForEvent(
-                                         event, &event_display_id_));
+    StartTrackingPointer(pointer_id, pointer_target_found);
     return;
   }
 
-  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 ==
+  if (pointer_target_found.window == pointer_targets_[pointer_id].window &&
+      pointer_target_found.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)
+    if (pointer_target_found.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);
+  StartTrackingPointer(pointer_id, pointer_target_found);
 }
 
 bool EventDispatcher::AreAnyPointersDown() const {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.is_pointer_down)
       return true;
   }
   return false;
 }
 
@@ skipping 140 matching lines @@
   if (mouse_cursor_source_window_ == window)
     SetMouseCursorSourceWindow(nullptr);
 }
 
 void EventDispatcher::OnDragCursorUpdated() {
   delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 }  // namespace ws
 }  // namespace ui