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 44 matching lines @@
     POST_ONLY,
   };
 
   explicit EventDispatcher(EventDispatcherDelegate* delegate);
   ~EventDispatcher() override;
 
   // Cancels capture and stops tracking any pointer events. This does not send
   // any events to the delegate.
   void Reset();
 
+  const EventTargeter* event_targeter() const { return event_targeter_.get(); }

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

EventTargeter is an implementation detail of EventDispatcher and we shouldn't
need to expose it. Add a IsProcessingEvent() here that WindowManagerState calls
to.

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

True, done.

+
   void SetMousePointerDisplayLocation(const gfx::Point& display_location,
-                                      const int64_t display_id);
+                                      int64_t display_id);
   const gfx::Point& mouse_pointer_last_location() const {
     return mouse_pointer_last_location_;
   }
   int64_t mouse_pointer_display_id() const { return mouse_pointer_display_id_; }
 
   // Returns the cursor for the current target, or POINTER if the mouse is not
   // over a valid target.
   ui::CursorData GetCurrentMouseCursor() const;
 
   // |capture_window_| will receive all input. See window_tree.mojom for
@@ skipping 63 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.
+  // This may be asynchronous if we need to find the target window for |event|
+  // asynchronously.
   void ProcessEvent(const ui::Event& event,
-                    const int64_t display_id,
+                    int64_t display_id,
                     AcceleratorMatchPhase match_phase);
 
   // EventTargeterDelegate:
   ServerWindow* GetRootWindowContaining(gfx::Point* location_in_display,
                                         int64_t* display_id) override;
+  void ProcessNextEventFromQueue() override;
 
  private:
   friend class test::EventDispatcherTestApi;
 
   void SetMouseCursorSourceWindow(ServerWindow* window);
 
+  // Called after we found the target for the current mouse cursor to see if
+  // |mouse_pointer_last_location_| and |mouse_pointer_display_id_| need to be
+  // updated based on the new target we found. No need to call delegate's
+  // OnMouseCursorLocationChanged since mouse location is the same in
+  // screen-coord.
+  // TODO(riajiang): No need to update mouse location after ozone drm can tell
+  // us the right display the cursor is on for drag-n-drop events.
+  // crbug.com/726470
+  void SetMousePointerLocation(const gfx::Point& new_mouse_location,
+                               int64_t new_mouse_display_id);
+
   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);
+  // |pointer_target| is the PointerTarget for |event| based on the
+  // |deepest_window|, the deepest visible window for the root_location
+  // of the |event|. |location_in_display| and |display_id| are updated values
+  // for root_location and |event_display_id_| (e.g. during drag-n-drop).
+  void ProcessPointerEventOnFoundTarget(const ui::PointerEvent& event,
+                                        const PointerTarget& pointer_target,
+                                        const DeepestWindow& deepest_window,
+                                        const gfx::Point& location_in_display,
+                                        int64_t display_id);
+
+  void UpdateNonClientAreaForCurrentWindowOnFoundWindow(
+      const DeepestWindow& deepest_window,
+      const gfx::Point& location_in_display,
+      int64_t display_id);
+  void UpdateCursorProviderByLastKnownLocationOnFoundWindow(
+      const DeepestWindow& deepest_window,
+      const gfx::Point& location_in_display,
+      int64_t display_id);
 
   // 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);
 
   // 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,
@@ skipping 75 matching lines @@
       AcceleratorMatchPhase::ANY;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace ui
 
 #endif  // SERVICES_UI_WS_EVENT_DISPATCHER_H_