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 206 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(

[sky, 2017/05/31 23:36:34]

Can all the calls to async code DCHECK if there is an async call in flight?

[riajiang, 2017/06/01 18:22:11]

In EventTargeter::FindDeepestVisibleWindowForEvents, |location| is going to be
put in the request queue if there's a hit-test in flight, and then in
EventTargeter::FindDeepestVisibleWindowForEventsImpl there's a DCHECK before we
start async targeting. Were you thinking sth like this?

[sky, 2017/06/01 21:12:58]

My question is how do we end up in
EventTargeter::FindDeepestVisibleWindowForEvents() with an async event already
in the queue? In an earlier thread we agreed there should be at most one async
request per event.

[riajiang, 2017/06/01 22:00:21]

EventTargeter::FindDeepestVisibleWindowForEvents() can also be called from
EventDispatcher::UpdateNonClientAreaForCurrentWindow() and 
EventDispatcher::UpdateCursorProviderByLastKnownLocation() when things like
window hierarchy and bounds changed without an input event, so
FindDeepestVisibleWindowForEvents() can be called when there's a hit-test in
flight already. I think it would be hard to DCHECK that there's at most one
async request per event because we can be handling an input event and receiving
window hierarchy change request at the same time?

(I can rename FindDeepestVisibleWindowForEvents to
FindDeepestVisibleWindowForLocation?)

+        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 60 matching lines @@
   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) {
+  if (new_mouse_location != mouse_pointer_last_location_)

[sky, 2017/05/31 23:36:34]

Is there a reason not to set the values all the time? That is, get rid of the if
and always set?

[riajiang, 2017/06/01 18:22:11]

Removed if. I was thinking that we don't have to set if values are the same? In
general, do we only check that if it's an expensive assignment?

+    mouse_pointer_last_location_ = new_mouse_location;
+  if (new_mouse_display_id != mouse_pointer_display_id_)
+    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());
+  event_targeter_->PointerTargetForEvent(

[sky, 2017/05/31 23:36:34]

As this is a single line now (albeit a long single line) how about moving to the
single place that calls this function?

[riajiang, 2017/06/01 18:22:11]

True, moved to ProcessEvent.

+      event, event_display_id_,
+      base::BindOnce(&EventDispatcher::ProcessPointerEventOnFoundTarget,
+                     base::Unretained(this), event));
+}
+
+void EventDispatcher::ProcessPointerEventOnFoundTarget(
+    const ui::PointerEvent& event,
+    const PointerTarget& pointer_target_found,
+    const DeepestWindow& deepest_window,
+    const gfx::Point& new_location,
+    const int64_t new_display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();
+
+  std::unique_ptr<ui::Event> cloned_event = ui::Event::Clone(event);
+  if (new_display_id != event_display_id_) {
+    event_display_id_ = new_display_id;
+    cloned_event->AsLocatedEvent()->set_root_location(new_location);
+  }
+
   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(new_location, new_display_id);
+    delegate_->OnMouseCursorLocationChanged(new_location, new_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, new_location, new_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::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) {
   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);
+}
+
+void EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+    const DeepestWindow& deepest_window,
+    const gfx::Point& new_location,
+    const int64_t new_display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();
+
+  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(new_location, new_display_id);
+  delegate_->UpdateNativeCursorFromDispatcher();
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+    const DeepestWindow& deepest_window,
+    const gfx::Point& new_location,
+    const int64_t new_display_id) {
+  event_targeter_->ProcessNextHittesetRequestFromQueue();
+  UpdateCursorProviderByLastKnownLocationWithWindow(
+      deepest_window, new_location, new_display_id);
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationWithWindow(
+    const DeepestWindow& deepest_window,
+    const gfx::Point& new_location,
+    const int64_t new_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;
+  }
+  UpdateMousePointerLocation(new_location, new_display_id);
+  delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 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