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>
@@ skipping 104 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);
 
   // 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
@@ skipping 19 matching lines @@
     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(gfx::Point location, HittestCallback hittest_callback);

[sky, 2017/05/14 15:59:05]

const gfx::Point&

[riajiang, 2017/05/15 18:34:41]

Done.

+    ~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
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_DISPATCHER_H_