Make event-targeting asynchronous in window server.

services/ui/ws/event_dispatcher.h

 // 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.
 
 #ifndef SERVICES_UI_WS_EVENT_DISPATCHER_H_
 #define SERVICES_UI_WS_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/cursor/cursor.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "services/ui/ws/drag_cursor_updater.h"
 #include "services/ui/ws/modal_window_controller.h"
 #include "services/ui/ws/server_window_observer.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace ui {
 class Event;
@@ skipping 90 matching lines @@
     return mouse_cursor_source_window_;
   }
 
   // Returns the window the mouse cursor is taken from. This does not take
   // into account drags. In other words if there is a drag on going the mouse
   // comes comes from a different window.
   const ServerWindow* GetWindowForMouseCursor() const;
 
   // If the mouse cursor is still over |mouse_cursor_source_window_|, updates
   // whether we are in the non-client area. Used when
-  // |mouse_cursor_source_window_| has changed its properties.
-  void UpdateNonClientAreaForCurrentWindow();
+  // |mouse_cursor_source_window_| has changed its properties. |callback| is
+  // called after the update is finished.
+  void UpdateNonClientAreaForCurrentWindow(const base::Closure& callback);

[sky, 2017/05/15 21:20:23]

Having any of these functions take callbacks makes the code hard to reason
about. In fact I'm struggling to know if there aren't any unwanted side effects.
For processing that needs to happen after the fact how about adding functions to
the delegate interface that are called at the right time? The code in
WindowServer that runs after updating the native cursor would move to
WindowManagerState as WindowManagerState is the EventDispatcherDelegate.

[riajiang, 2017/05/17 02:01:59]

Makes sense! With erg@'s CL https://codereview.chromium.org/2857963003, I think
it would be sufficient to use the existing
WindowManagerState::UpdateNativeCursorFromDispatcher() after updating the native
cursor?

 
   // Possibly updates the cursor. If we aren't in an implicit capture, we take
   // the last known location of the mouse pointer, and look for the
-  // ServerWindow* under it.
-  void UpdateCursorProviderByLastKnownLocation();
+  // ServerWindow* under it. |callback| is called after the update is finished.
+  void UpdateCursorProviderByLastKnownLocation(const base::Closure& callback);
 
   // Adds an accelerator with the given id and event-matcher. If an accelerator
   // already exists with the same id or the same matcher, then the accelerator
   // is not added. Returns whether adding the accelerator was successful or not.
   bool AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher);
 
   void RemoveAccelerator(uint32_t id);
 
   // Processes the supplied event, informing the delegate as approriate. This
   // may result in generating any number of events. If |match_phase| is
   // ANY and there is a matching accelerator with PRE_TARGET found, than only
   // OnAccelerator() is called. The expectation is after the PRE_TARGET has been
   // handled this is again called with an AcceleratorMatchPhase of POST_ONLY.
   void ProcessEvent(const ui::Event& event, AcceleratorMatchPhase match_phase);
 
+  bool HittestInFlight();

[sky, 2017/05/15 21:20:23]

IsHitTestInFlight() and const. Also, use HitTest everywhere (we use HitTest in
ui/base/hit_test for one).

[riajiang, 2017/05/17 02:01:59]

Done.

+
  private:
   friend class test::EventDispatcherTestApi;
 
   // Keeps track of state associated with an active pointer.
   struct PointerTarget {
     PointerTarget()
         : window(nullptr),
           is_mouse_event(false),
           in_nonclient_area(false),
           is_pointer_down(false) {}
 
     // The target window, which may be null. null is used in two situations:
     // when there is no valid window target, or there was a target but the
     // window is destroyed before a corresponding release/cancel.
     ServerWindow* window;
 
     bool is_mouse_event;
 
     // Did the pointer event start in the non-client area.
     bool in_nonclient_area;
 
     bool is_pointer_down;
   };
 
+  using PointerTargetForEventCallback = base::OnceCallback<void(PointerTarget)>;
+  using HittestCallback = base::OnceCallback<void(DeepestWindow)>;
+
+  struct HittestRequest {
+    HittestRequest(const gfx::Point& location,
+                   HittestCallback hittest_callback);
+    ~HittestRequest();
+
+    gfx::Point hittest_location;
+    HittestCallback hittest_callback;
+  };
+
   void SetMouseCursorSourceWindow(ServerWindow* window);
 
   void ProcessKeyEvent(const ui::KeyEvent& event,
                        AcceleratorMatchPhase match_phase);
 
   bool IsTrackingPointer(int32_t pointer_id) const {
     return pointer_targets_.count(pointer_id) > 0;
   }
 
   // EventDispatcher provides the following logic for pointer events:
   // . wheel events go to the current target of the associated pointer. If
   //   there is no target, they go to the deepest window.
   // . move (not drag) events go to the deepest window.
   // . when a pointer goes down all events until the corresponding up or
   //   cancel go to the deepest target. For mouse events the up only occurs
   //   when no buttons on the mouse are down.
   // This also generates exit events as appropriate. For example, if the mouse
   // moves between one window to another an exit is generated on the first.
   void ProcessPointerEvent(const ui::PointerEvent& event);
+  void ProcessPointerEventOnFoundTarget(const ui::PointerEvent& event,
+                                        PointerTarget pointer_target_found);
 
   // Adds |pointer_target| to |pointer_targets_|.
   void StartTrackingPointer(int32_t pointer_id,
                             const PointerTarget& pointer_target);
 
   // Removes a PointerTarget from |pointer_targets_|.
   void StopTrackingPointer(int32_t pointer_id);
 
   // Starts tracking the pointer for |event|, or if already tracking the
   // pointer sends the appropriate event to the delegate and updates the
   // currently tracked PointerTarget appropriately.
   void UpdateTargetForPointer(int32_t pointer_id,
-                              const ui::LocatedEvent& event);
+                              const ui::PointerEvent& event,
+                              const PointerTarget& pointer_target_found);
 
-  // Returns a PointerTarget for the supplied event. If there is no valid
-  // event target for the specified location |window| in the returned value is
-  // null.
-  PointerTarget PointerTargetForEvent(const ui::LocatedEvent& event);
+  // |callback| is called with a PointerTarget for the supplied event. If there
+  // is no valid event target for the specified location |window| in the
+  // returned value is null.
+  void PointerTargetForEvent(const ui::PointerEvent& event,
+                             PointerTargetForEventCallback callback);
+  void PointerTargetForEventOnFoundWindow(
+      const ui::PointerEvent& event,
+      PointerTargetForEventCallback callback,
+      DeepestWindow deepest_window);
 
   // Returns true if any pointers are in the pressed/down state.
   bool AreAnyPointersDown() const;
 
   // If |target->window| is valid, then passes the event to the delegate.
   void DispatchToPointerTarget(const PointerTarget& target,
                                const ui::LocatedEvent& event);
 
   // Dispatch |event| to the delegate.
   void DispatchToClient(ServerWindow* window,
                         ClientSpecificId client_id,
                         const ui::LocatedEvent& event);
 
   // Stops sending pointer events to |window|. This does not remove the entry
   // for |window| from |pointer_targets_|, rather it nulls out the window. This
   // way we continue to eat events until the up/cancel is received.
   void CancelPointerEventsToTarget(ServerWindow* window);
 
   // Used to observe a window. Can be called multiple times on a window. To
   // unobserve a window, UnobserveWindow() should be called the same number of
   // times.
   void ObserveWindow(ServerWindow* winodw);
   void UnobserveWindow(ServerWindow* winodw);
 
   // Returns an Accelerator bound to the specified code/flags, and of the
   // matching |phase|. Otherwise returns null.
   Accelerator* FindAccelerator(const ui::KeyEvent& event,
                                const ui::mojom::AcceleratorPhase phase);
 
-  DeepestWindow FindDeepestVisibleWindowForEvents(const gfx::Point& location);
+  // Call WindowFinder to find the deepest visible window for |location|.
+  // |callback| is called with the window found.
+  void FindDeepestVisibleWindowForEvents(const gfx::Point& location,
+                                         HittestCallback callback);
+  void FindDeepestVisibleWindowForEventsImpl(const gfx::Point& location,
+                                             HittestCallback callback);
+  void FindDeepestVisibleWindowForEventsAsync(const gfx::Point& location,
+                                              HittestCallback callback);
+
+  void UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+      const base::Closure& callback,
+      DeepestWindow deepest_window);
+  void UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+      const base::Closure& callback,
+      DeepestWindow deepest_window);
+
+  void ProcessNextHittesetRequestFromQueue();
 
   // Clears the implicit captures in |pointer_targets_|, with the exception of
   // |window|. |window| may be null. |client_id| is the target client of
   // |window|.
   void CancelImplicitCaptureExcept(ServerWindow* window,
                                    ClientSpecificId client_id);
 
   // ServerWindowObserver:
   void OnWillChangeWindowHierarchy(ServerWindow* window,
                                    ServerWindow* new_parent,
@@ skipping 16 matching lines @@
   bool mouse_button_down_;
   ServerWindow* mouse_cursor_source_window_;
   bool mouse_cursor_in_non_client_area_;
 
   // The on screen location of the mouse pointer. This can be outside the
   // bounds of |mouse_cursor_source_window_|, which can capture the cursor.
   gfx::Point mouse_pointer_last_location_;
 
   std::map<uint32_t, std::unique_ptr<Accelerator>> accelerators_;
 
+  // True if we are waiting for the result of a hit-test. False otherwise.
+  bool hittest_in_flight_;
+  std::queue<std::unique_ptr<HittestRequest>> hittest_request_queue_;
+
   using PointerIdToTargetMap = std::map<int32_t, PointerTarget>;
   // |pointer_targets_| contains the active pointers. For a mouse based pointer
   // a PointerTarget is always active (and present in |pointer_targets_|). For
   // touch based pointers the pointer is active while down and removed on
   // cancel or up.
   PointerIdToTargetMap pointer_targets_;
 
   // Keeps track of number of observe requests for each observed window.
   std::map<const ServerWindow*, uint8_t> observed_windows_;
 
 #if !defined(NDEBUG)
   std::unique_ptr<ui::Event> previous_event_;
   AcceleratorMatchPhase previous_accelerator_match_phase_ =
       AcceleratorMatchPhase::ANY;
 #endif
 
+  base::WeakPtrFactory<EventDispatcher> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_DISPATCHER_H_