Make event-targeting asynchronous in window server.

services/ui/ws/event_targeter.h

 // 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.
 
 #ifndef SERVICES_UI_WS_EVENT_TARGETER_H_
 #define SERVICES_UI_WS_EVENT_TARGETER_H_
 
 #include <stdint.h>
+#include <queue>
 
+#include "base/callback.h"
 #include "base/macros.h"
-
-namespace gfx {
-class Point;
-}
+#include "base/memory/weak_ptr.h"
+#include "ui/gfx/geometry/point.h"
 
 namespace ui {
-class LocatedEvent;
+class PointerEvent;
 
 namespace ws {
 struct DeepestWindow;
 class EventTargeterDelegate;
 class ModalWindowController;
 class ServerWindow;
 
 // Keeps track of state associated with an active pointer.
 struct PointerTarget {

[sky, 2017/06/02 23:28:20]

Sorry for not realizing this sooner, but PointerTarget is specific to event
dispatching and shouldn't have been moved here. Specifically is_mouse_event and
is_pointer_down are state only useful for EventDispatcher. Both of the functions
you have (PointerTargetForEvent and FindDeepestVisibleWindowForLocation) are the
exact same thing, (and you have one calling the other). How about a single
function called GetEventTarget or FindTarget? The callback can take a structure
if you want, but not both DeepestWindow and other information.

[riajiang, 2017/06/05 23:56:15]

Ah I see, makes sense. Moved PointerTarget back to EventDispatcher and added
LocationTarget struct for the HitTestCallback return type. Changed to only have
FindTargetForLocation.

   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(const PointerTarget&,
+                            const DeepestWindow&,
+                            const gfx::Point&,
+                            int64_t)>;
+using HitTestCallback =
+    base::OnceCallback<void(const DeepestWindow&, const gfx::Point&, int64_t)>;
+
 // Finds the PointerTarget for an event or the DeepestWindow for a location.
 class EventTargeter {
  public:
   EventTargeter(EventTargeterDelegate* event_targeter_delegate,
                 ModalWindowController* modal_window_controller);
   ~EventTargeter();
 
-  // 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,
-                                      int64_t* display_id);
+  // |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,
+                             int64_t display_id,
+                             PointerTargetForEventCallback callback);
 
-  // Returns a DeepestWindow for the supplied |location|. If there is no valid
-  // root window, |window| in the returned value is null.
-  DeepestWindow FindDeepestVisibleWindowForEvents(gfx::Point* location,
-                                                  int64_t* display_id);
+  // Calls WindowFinder to find the deepest visible window for |location|.
+  // |callback| is called with the window found.
+  void FindDeepestVisibleWindowForLocation(const gfx::Point& location,
+                                           int64_t display_id,
+                                           HitTestCallback callback);
+
+  bool IsHitTestInFlight() const;
 
  private:
+  struct HitTestRequest {
+    HitTestRequest(const gfx::Point& location,
+                   int64_t display_id,
+                   HitTestCallback hittest_callback);
+    ~HitTestRequest();
+
+    gfx::Point location;
+    int64_t display_id;
+    HitTestCallback callback;
+  };
+
+  void PointerTargetForEventOnFoundWindow(const ui::PointerEvent& event,
+                                          const DeepestWindow& deepest_window,
+                                          const gfx::Point& location_in_display,
+                                          int64_t display_id);
+
+  void FindDeepestVisibleWindowForLocationImpl(const gfx::Point& location,
+                                               int64_t display_id);
+
+  void FindDeepestVisibleWindowForLocationAsync(const gfx::Point& location,
+                                                int64_t display_id);
+
+  void ProcessNextHittesetRequestFromQueue();
+
   EventTargeterDelegate* event_targeter_delegate_;
+
   ModalWindowController* modal_window_controller_;
 
+  PointerTargetForEventCallback target_callback_;
+  HitTestCallback hit_test_callback_;
+
+  // True if we are waiting for the result of a hit-test. False otherwise.
+  bool hit_test_in_flight_;
+
+  // Request would go into this queue if it's coming from EventDispatcher::
+  // UpdateNonClientAreaForCurrentWindow() or EventDispatcher::
+  // UpdateCursorProviderByLastKnownLocation(). If it's an event that needs
+  // targeting, it would only go to WindowManagerState::event_queue_ when it's
+  // waiting for an active hit-test.
+  std::queue<std::unique_ptr<HitTestRequest>> hit_test_request_queue_;
+
+  base::WeakPtrFactory<EventTargeter> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(EventTargeter);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_TARGETER_H_