Make event-targeting asynchronous in window server.

services/ui/ws/event_targeter.cc

 // Copyright 2017 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_targeter.h"
 
+#include "base/command_line.h"
+#include "base/task_scheduler/post_task.h"
 #include "services/ui/ws/event_dispatcher_delegate.h"
 #include "services/ui/ws/modal_window_controller.h"
 #include "services/ui/ws/window_finder.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace ui {
 namespace ws {
 
+EventTargeter::HitTestRequest::HitTestRequest(gfx::Point* location,
+                                              int64_t* display_id,
+                                              HitTestCallback callback)
+    : hittest_location(location),
+      hittest_display_id(display_id),
+      hittest_callback(std::move(callback)) {}
+
+EventTargeter::HitTestRequest::~HitTestRequest() {}
+
 EventTargeter::EventTargeter(EventDispatcherDelegate* event_dispatcher_delegate,
                              ModalWindowController* modal_window_controller)
     : event_dispatcher_delegate_(event_dispatcher_delegate),
-      modal_window_controller_(modal_window_controller) {}
+      modal_window_controller_(modal_window_controller),
+      hittest_in_flight_(false),
+      weak_ptr_factory_(this) {}
 
 EventTargeter::~EventTargeter() {}
 
-PointerTarget EventTargeter::PointerTargetForEvent(
-    const ui::LocatedEvent& event,
-    int64_t* display_id) {
+void EventTargeter::PointerTargetForEvent(
+    const ui::PointerEvent& event,
+    int64_t* display_id,
+    PointerTargetForEventCallback callback) {
+  target_callback_ = std::move(callback);
+  current_hittest_location_.reset(new gfx::Point(event.root_location()));
+  FindDeepestVisibleWindowForEvents(
+      current_hittest_location_.get(), display_id,
+      base::BindOnce(&EventTargeter::PointerTargetForEventOnFoundWindow,
+                     weak_ptr_factory_.GetWeakPtr(), event));
+}
+
+void EventTargeter::FindDeepestVisibleWindowForEvents(
+    gfx::Point* location,
+    int64_t* display_id,
+    HitTestCallback callback) {
+  if (IsHitTestInFlight()) {
+    std::unique_ptr<HitTestRequest> hittest_request =
+        base::MakeUnique<HitTestRequest>(location, display_id,
+                                         std::move(callback));
+    hittest_request_queue_.push(std::move(hittest_request));
+    return;
+  }
+
+  hittest_callback_ = std::move(callback);
+  FindDeepestVisibleWindowForEventsImpl(location, display_id);
+}
+
+void EventTargeter::ProcessNextHittesetRequestFromQueue() {
+  hittest_in_flight_ = false;
+  if (hittest_request_queue_.empty()) {
+    event_dispatcher_delegate_->ProcessNextEventFromQueue();
+    return;
+  }
+  std::unique_ptr<HitTestRequest> hittest_request =
+      std::move(hittest_request_queue_.front());
+
+  hittest_request_queue_.pop();
+  hittest_callback_ = std::move(hittest_request->hittest_callback);
+  FindDeepestVisibleWindowForEventsImpl(hittest_request->hittest_location,
+                                        hittest_request->hittest_display_id);
+}
+
+bool EventTargeter::IsHitTestInFlight() const {
+  if (hittest_in_flight_ || !hittest_request_queue_.empty())
+    return true;
+  return false;
+}
+
+void EventTargeter::PointerTargetForEventOnFoundWindow(
+    const ui::PointerEvent& event,
+    DeepestWindow deepest_window) {
   PointerTarget pointer_target;
-  gfx::Point event_root_location(event.root_location());
-  DeepestWindow deepest_window =
-      FindDeepestVisibleWindowForEvents(&event_root_location, 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;
+  base::ResetAndReturn(&target_callback_).Run(pointer_target);
 }
 
-DeepestWindow EventTargeter::FindDeepestVisibleWindowForEvents(
+void EventTargeter::FindDeepestVisibleWindowForEventsImpl(gfx::Point* location,
+                                                          int64_t* display_id) {
+  // 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(&EventTargeter::FindDeepestVisibleWindowForEventsAsync,
+                       weak_ptr_factory_.GetWeakPtr(), location, display_id));
+  } else {
+    FindDeepestVisibleWindowForEventsAsync(location, display_id);
+  }
+}
+
+void EventTargeter::FindDeepestVisibleWindowForEventsAsync(
     gfx::Point* location,
     int64_t* display_id) {
   ServerWindow* root =
       event_dispatcher_delegate_->GetRootWindowContaining(location, display_id);
-  return root ? ui::ws::FindDeepestVisibleWindowForEvents(root, *location)
-              : DeepestWindow();
+  if (root) {
+    base::ResetAndReturn(&hittest_callback_)
+        .Run(ui::ws::FindDeepestVisibleWindowForEvents(root, *location));
+  } else {
+    base::ResetAndReturn(&hittest_callback_).Run(DeepestWindow());
+  }
 }
 
 }  // namespace ws
 }  // namespace ui