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 61 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) {
+    int64_t display_id) {
   DCHECK(pointer_targets_.empty());
   SetMousePointerLocation(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 {
@@ skipping 121 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_) {
-    LocationTarget location_target = event_targeter_->FindTargetForLocation(
-        mouse_pointer_last_location_, mouse_pointer_display_id_);
-    if (location_target.deepest_window.window == mouse_cursor_source_window_) {
-      mouse_cursor_in_non_client_area_ =
-          mouse_cursor_source_window_
-              ? location_target.deepest_window.in_non_client_area
-              : false;
-    }
-    SetMousePointerLocation(location_target.location_in_root,
-                            location_target.display_id);
+    event_targeter_->FindTargetForLocation(
+        mouse_pointer_last_location_, mouse_pointer_display_id_,
+        base::BindOnce(
+            &EventDispatcher::UpdateNonClientAreaForCurrentWindowOnFoundWindow,
+            base::Unretained(this)));

[sadrul, 2017/06/07 20:16:04]

I guess using base::Unretained here (and below) is safe because EventDispatcher
owns |event_targeter_|?

[riajiang, 2017/06/07 21:46:25]

Yes so |this| still exists when the callback is run.

   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
-    LocationTarget location_target = event_targeter_->FindTargetForLocation(
-        mouse_pointer_last_location_, mouse_pointer_display_id_);
-    SetMouseCursorSourceWindow(location_target.deepest_window.window);
-    if (mouse_cursor_source_window_) {
-      mouse_cursor_in_non_client_area_ =
-          location_target.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;
-    }
-    SetMousePointerLocation(location_target.location_in_root,
-                            location_target.display_id);
+    event_targeter_->FindTargetForLocation(
+        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 11 matching lines @@
   return true;
 }
 
 void EventDispatcher::RemoveAccelerator(uint32_t id) {
   auto it = accelerators_.find(id);
   // Clients may pass bogus ids.
   if (it != accelerators_.end())
     accelerators_.erase(it);
 }
 
+bool EventDispatcher::IsProcessingEvent() {
+  return event_targeter_->IsHitTestInFlight();
+}
+
 void EventDispatcher::ProcessEvent(const ui::Event& event,
-                                   const int64_t display_id,
+                                   int64_t display_id,
                                    AcceleratorMatchPhase match_phase) {
 #if !defined(NDEBUG)
   if (match_phase == AcceleratorMatchPhase::POST_ONLY) {
     // POST_ONLY should always be preceeded by ANY with the same event.
     DCHECK(previous_event_);
     // Event doesn't define ==, so this compares the key fields.
     DCHECK(event.type() == previous_event_->type() &&
            event.time_stamp() == previous_event_->time_stamp() &&
            event.flags() == previous_event_->flags());
     DCHECK_EQ(previous_accelerator_match_phase_, AcceleratorMatchPhase::ANY);
@@ skipping 12 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_->FindTargetForLocation(
+      event.AsPointerEvent()->root_location(), event_display_id_,
+      base::BindOnce(&EventDispatcher::ProcessPointerEventOnFoundTarget,
+                     base::Unretained(this), *event.AsPointerEvent()));
 }
 
 ServerWindow* EventDispatcher::GetRootWindowContaining(
     gfx::Point* location_in_display,
     int64_t* display_id) {
   return delegate_->GetRootWindowContaining(location_in_display, display_id);
 }
 
+void EventDispatcher::ProcessNextEventFromQueue() {
+  delegate_->ProcessNextEventFromQueue();
+}
+
 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 24 matching lines @@
     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 LocationTarget& location_target) {
   PointerTarget pointer_target;
-  LocationTarget location_target = event_targeter_->FindTargetForLocation(
-      event.root_location(), event_display_id_);
   pointer_target.window = modal_window_controller_.GetTargetForWindow(
       location_target.deepest_window.window);
   pointer_target.is_mouse_event = event.IsMousePointerEvent();
   pointer_target.in_nonclient_area =
       location_target.deepest_window.window != pointer_target.window ||
       !pointer_target.window ||
       location_target.deepest_window.in_non_client_area;
   pointer_target.is_pointer_down = event.type() == ui::ET_POINTER_DOWN;
 
   std::unique_ptr<ui::Event> cloned_event = ui::Event::Clone(event);
@@ skipping 68 matching lines @@
       }
     }
   }
 
   // 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();
+    UpdateCursorProviderByLastKnownLocationOnFoundWindow(location_target);
 
   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 LocationTarget& location_target) {
+  if (!mouse_cursor_source_window_)
+    return;
+
+  if (location_target.deepest_window.window == mouse_cursor_source_window_) {
+    mouse_cursor_in_non_client_area_ =
+        mouse_cursor_source_window_
+            ? location_target.deepest_window.in_non_client_area
+            : false;
+  }
+  SetMousePointerLocation(location_target.location_in_root,
+                          location_target.display_id);
+  delegate_->UpdateNativeCursorFromDispatcher();
+}
+
+void EventDispatcher::UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+    const LocationTarget& location_target) {
+  if (mouse_button_down_)
+    return;
+
+  SetMouseCursorSourceWindow(location_target.deepest_window.window);
+  if (mouse_cursor_source_window_) {
+    mouse_cursor_in_non_client_area_ =
+        location_target.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;
+  }
+  SetMousePointerLocation(location_target.location_in_root,
+                          location_target.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) {
@@ skipping 189 matching lines @@
   if (mouse_cursor_source_window_ == window)
     SetMouseCursorSourceWindow(nullptr);
 }
 
 void EventDispatcher::OnDragCursorUpdated() {
   delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 }  // namespace ws
 }  // namespace ui