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/command_line.h"
 #include "base/memory/ptr_util.h"
+#include "base/task_scheduler/post_task.h"
 #include "base/time/time.h"
 #include "services/ui/ws/accelerator.h"
 #include "services/ui/ws/drag_controller.h"
 #include "services/ui/ws/drag_source.h"
 #include "services/ui/ws/event_dispatcher_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/window_coordinate_conversions.h"
 #include "services/ui/ws/window_finder.h"
 #include "ui/base/cursor/cursor.h"
@@ skipping 14 matching lines @@
                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;
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
+EventDispatcher::HittestRequest::HittestRequest(const gfx::Point& location,
+                                                HittestCallback callback)
+    : hittest_location(location) {
+  hittest_callback = std::move(callback);
+}
+
+EventDispatcher::HittestRequest::~HittestRequest() {}
+
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       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) {}
+      mouse_cursor_in_non_client_area_(false),
+      hittest_in_flight_(false),
+      weak_ptr_factory_(this) {}
 
 EventDispatcher::~EventDispatcher() {
   SetMouseCursorSourceWindow(nullptr);
   if (capture_window_) {
     UnobserveWindow(capture_window_);
     capture_window_ = nullptr;
     capture_window_client_id_ = kInvalidClientId;
   }
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window)
@@ skipping 11 matching lines @@
   while (!pointer_targets_.empty())
     StopTrackingPointer(pointer_targets_.begin()->first);
 
   mouse_button_down_ = false;
 }
 
 void EventDispatcher::SetMousePointerScreenLocation(
     const gfx::Point& screen_location) {
   DCHECK(pointer_targets_.empty());
   mouse_pointer_last_location_ = screen_location;
-  UpdateCursorProviderByLastKnownLocation();
+  UpdateCursorProviderByLastKnownLocation(base::Closure());
   // 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(screen_location);
 }
 
 ui::CursorData EventDispatcher::GetCurrentMouseCursor() const {
   if (drag_controller_)
     return drag_controller_->current_cursor();
 
@@ skipping 44 matching lines @@
   // 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(window);
   } else {
     delegate_->ReleaseNativeCapture();
     if (!mouse_button_down_)
-      UpdateCursorProviderByLastKnownLocation();
+      UpdateCursorProviderByLastKnownLocation(base::Closure());
   }
   return true;
 }
 
 void EventDispatcher::SetDragDropSourceWindow(
     DragSource* drag_source,
     ServerWindow* window,
     DragTargetConnection* source_connection,
     int32_t drag_pointer,
     const std::unordered_map<std::string, std::vector<uint8_t>>& mime_data,
@@ skipping 51 matching lines @@
   // an embed root. This is done to match the behavior of aura, which sets the
   // cursor on the root.
   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() {
+void EventDispatcher::UpdateNonClientAreaForCurrentWindow(
+    const base::Closure& callback) {
   if (mouse_cursor_source_window_) {
-    DeepestWindow deepest_window =
-        FindDeepestVisibleWindowForEvents(mouse_pointer_last_location_);
-    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;
-    }
+    FindDeepestVisibleWindowForEvents(
+        mouse_pointer_last_location_,
+        base::BindOnce(
+            &EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow,
+            weak_ptr_factory_.GetWeakPtr(), callback));
   }
 }
 
-void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
+void EventDispatcher::UpdateCursorProviderByLastKnownLocation(
+    const base::Closure& callback) {
   if (!mouse_button_down_) {
-    DeepestWindow deepest_window =
-        FindDeepestVisibleWindowForEvents(mouse_pointer_last_location_);
-    SetMouseCursorSourceWindow(deepest_window.window);
-    if (mouse_cursor_source_window_) {
-      mouse_cursor_in_non_client_area_ = deepest_window.in_non_client_area;
-    } else {
-      gfx::Point location = mouse_pointer_last_location_;
-      SetMouseCursorSourceWindow(delegate_->GetRootWindowContaining(&location));
-      mouse_cursor_in_non_client_area_ = true;
-    }
+    FindDeepestVisibleWindowForEvents(
+        mouse_pointer_last_location_,
+        base::BindOnce(&EventDispatcher::
+                           UpdateCursorProviderByLastKnownLocationOnFoundWindow,
+                       weak_ptr_factory_.GetWeakPtr(), callback));
   }
 }
 
 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 47 matching lines @@
     }
     ProcessKeyEvent(*key_event, match_phase);
     return;
   }
 
   DCHECK(event.IsPointerEvent());
   ProcessPointerEvent(*event.AsPointerEvent());
   return;
 }
 
+bool EventDispatcher::HittestInFlight() {
+  if (hittest_in_flight_ || !hittest_request_queue_.empty())
+    return true;
+  return false;
+}
+
 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_);
 }
@@ skipping 19 matching lines @@
     return;
   }
   delegate_->OnEventTargetNotFound(event);
   if (post_target)
     delegate_->OnAccelerator(post_target->id(), event,
                              EventDispatcherDelegate::AcceleratorPhase::POST);
 }
 
 void EventDispatcher::ProcessPointerEvent(const ui::PointerEvent& event) {
   DCHECK(event.IsPointerEvent());
+  PointerTargetForEvent(
+      event, base::BindOnce(&EventDispatcher::ProcessPointerEventOnFoundTarget,
+                            weak_ptr_factory_.GetWeakPtr(), event));
+}
+
+void EventDispatcher::ProcessPointerEventOnFoundTarget(
+    const ui::PointerEvent& event,
+    PointerTarget pointer_target_found) {
+  ProcessNextHittesetRequestFromQueue();
+
   const bool is_mouse_event = event.IsMousePointerEvent();
 
   if (is_mouse_event) {
     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()));
 
   // 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);
-    if (drag_controller_->DispatchPointerEvent(event, target.window))
+    if (drag_controller_->DispatchPointerEvent(event,
+                                               pointer_target_found.window))
       return;
   }
 
   if (capture_window_) {
     SetMouseCursorSourceWindow(capture_window_);
     DispatchToClient(capture_window_, capture_window_client_id_, event);
     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, event, 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();
           capture_window = delegate_->GetRootWindowContaining(&event_location);
         }
         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();
+    UpdateCursorProviderByLastKnownLocation(base::Closure());
 
   DispatchToPointerTarget(pointer_targets_[pointer_id], event);
 
   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();
@@ skipping 10 matching lines @@
 }
 
 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, PointerTargetForEvent(event));
+    StartTrackingPointer(pointer_id, pointer_target_found);
     return;
   }
 
-  const PointerTarget pointer_target = PointerTargetForEvent(event);
-  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);
 }
 
-EventDispatcher::PointerTarget EventDispatcher::PointerTargetForEvent(
-    const ui::LocatedEvent& event) {
+void EventDispatcher::PointerTargetForEvent(
+    const ui::PointerEvent& event,
+    PointerTargetForEventCallback callback) {
+  FindDeepestVisibleWindowForEvents(
+      event.root_location(),
+      base::BindOnce(&EventDispatcher::PointerTargetForEventOnFoundWindow,
+                     weak_ptr_factory_.GetWeakPtr(), event,
+                     std::move(callback)));
+}
+
+void EventDispatcher::PointerTargetForEventOnFoundWindow(
+    const ui::PointerEvent& event,
+    PointerTargetForEventCallback callback,
+    DeepestWindow deepest_window) {
   PointerTarget pointer_target;
-  DeepestWindow deepest_window =
-      FindDeepestVisibleWindowForEvents(event.root_location());
   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;
+  std::move(callback).Run(pointer_target);
 }
 
 bool EventDispatcher::AreAnyPointersDown() const {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.is_pointer_down)
       return true;
   }
   return false;
 }
 
@@ skipping 29 matching lines @@
   if (capture_window_ == window) {
     UnobserveWindow(window);
     capture_window_ = nullptr;
     capture_window_client_id_ = kInvalidClientId;
     mouse_button_down_ = false;
     // A window only cares to be informed that it lost capture if it explicitly
     // requested capture. A window can lose capture if another window gains
     // explicit capture.
     delegate_->OnCaptureChanged(nullptr, window);
     delegate_->ReleaseNativeCapture();
-    UpdateCursorProviderByLastKnownLocation();
+    UpdateCursorProviderByLastKnownLocation(base::Closure());
     return;
   }
 
   for (auto& pair : pointer_targets_) {
     if (pair.second.window == window) {
       UnobserveWindow(window);
       pair.second.window = nullptr;
     }
   }
 }
@@ skipping 19 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(
-    const gfx::Point& location) {
+void EventDispatcher::FindDeepestVisibleWindowForEvents(
+    const gfx::Point& location,
+    HittestCallback callback) {
+  if (HittestInFlight()) {
+    std::unique_ptr<HittestRequest> hittest_request =
+        base::MakeUnique<HittestRequest>(location, std::move(callback));
+    hittest_request_queue_.push(std::move(hittest_request));
+    return;
+  }
+
+  FindDeepestVisibleWindowForEventsImpl(location, std::move(callback));
+}
+
+void EventDispatcher::FindDeepestVisibleWindowForEventsImpl(
+    const gfx::Point& location,
+    HittestCallback callback) {
+  // TODO(riajiang): After HittestComponent is implemented, do synchronous
+  // hit-test for most cases using shared memory and only ask Blink
+  // asynchronously for hard cases. For now, assume all synchronous hit-tests
+  // failed if the "enable-async-event-targeting" flag is turned on.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          "enable-async-event-targeting")) {
+    DCHECK(!hittest_in_flight_);
+    hittest_in_flight_ = true;
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::BindOnce(&EventDispatcher::FindDeepestVisibleWindowForEventsAsync,
+                       weak_ptr_factory_.GetWeakPtr(), location,
+                       std::move(callback)));
+  } else {
+    FindDeepestVisibleWindowForEventsAsync(location, std::move(callback));
+  }
+}
+
+void EventDispatcher::FindDeepestVisibleWindowForEventsAsync(
+    const gfx::Point& location,
+    HittestCallback callback) {
   gfx::Point relative_location(location);
-  // For the case of no root.
   ServerWindow* root = delegate_->GetRootWindowContaining(&relative_location);
-  return root ? ui::ws::FindDeepestVisibleWindowForEvents(root,
-                                                          relative_location)
-              : DeepestWindow();
+  if (root) {
+    std::move(callback).Run(
+        ui::ws::FindDeepestVisibleWindowForEvents(root, relative_location));
+  } else {
+    std::move(callback).Run(DeepestWindow());
+  }
+}
+
+void EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+    const base::Closure& callback,
+    DeepestWindow deepest_window) {
+  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;
+  }
+  if (callback)
+    callback.Run();
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+    const base::Closure& callback,
+    DeepestWindow deepest_window) {
+  ProcessNextHittesetRequestFromQueue();
+
+  SetMouseCursorSourceWindow(deepest_window.window);
+  if (mouse_cursor_source_window_) {
+    mouse_cursor_in_non_client_area_ = deepest_window.in_non_client_area;
+  } else {
+    gfx::Point location = mouse_pointer_last_location_;
+    SetMouseCursorSourceWindow(delegate_->GetRootWindowContaining(&location));
+    mouse_cursor_in_non_client_area_ = true;
+  }
+  if (callback)
+    callback.Run();
+}
+
+void EventDispatcher::ProcessNextHittesetRequestFromQueue() {
+  hittest_in_flight_ = false;
+  if (hittest_request_queue_.empty())
+    return;
+  std::unique_ptr<HittestRequest> hittest_request =
+      std::move(hittest_request_queue_.front());
+  hittest_request_queue_.pop();
+  FindDeepestVisibleWindowForEventsImpl(
+      hittest_request->hittest_location,
+      std::move(hittest_request->hittest_callback));
 }
 
 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)
@@ skipping 52 matching lines @@
   if (mouse_cursor_source_window_ == window)
     SetMouseCursorSourceWindow(nullptr);
 }
 
 void EventDispatcher::OnDragCursorUpdated() {
   delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 }  // namespace ws
 }  // namespace ui