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 110 matching lines @@
   // 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);

[sky, 2017/05/22 16:06:56]

Update the description.

[riajiang, 2017/05/29 23:38:07]

Added that it may be asynchronous. 

 
+  bool IsHitTestInFlight() const;
+
  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);

[sky, 2017/05/22 16:06:56]

I understand you're doing this as an initial step in the direction of adding
async processing, but the heavy use of callbacks here makes this hard to follow.
Won't we end up with a real class that likely has a delegate? Would it better to
structure the code like that now? For example, I'm assuming the real hit test
class is likely to coalesce multiple requests in some cases, or possibly end up
synchronously processing. It's hard to see that now.

I recommend adding a real class now for the hit-testing that has a delegate. You
can make this class pure virtual if you want with two implementations. One that
processes everything async, then other sync. Does that make sense?

[riajiang, 2017/05/29 23:38:07]

As discussed, changed to use the new EventTargeter class (introduced in
https://codereview.chromium.org/2905333002) to make the code a bit cleaner.

+  void FindDeepestVisibleWindowForEventsImpl(const gfx::Point& location,
+                                             HitTestCallback callback);
+  void FindDeepestVisibleWindowForEventsAsync(const gfx::Point& location,
+                                              HitTestCallback callback);
+
+  void UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+      DeepestWindow deepest_window);
+  void UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+      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_;
+
+  // 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>> 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_