Keep root_location to be in pixels and display coordinates in WS.

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 41 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();
 
-  void SetMousePointerScreenLocation(const gfx::Point& screen_location);
+  void SetMousePointerDisplayLocationAndId(const gfx::Point& display_location,

[sky, 2017/05/17 16:53:41]

optional: the new name is rather verbose. Leave the old name, and add
display_id.

[riajiang, 2017/05/19 20:45:05]

Done.

+                                           const 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
   // details.
   ServerWindow* capture_window() { return capture_window_; }
   const ServerWindow* capture_window() const { return capture_window_; }
   // Setting capture can fail if the window is blocked by a modal window
@@ skipping 59 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);
+  void ProcessEvent(const ui::Event& event,
+                    const int64_t display_id,
+                    AcceleratorMatchPhase match_phase);
 
  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),
@@ skipping 23 matching lines @@
 
   // 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 ProcessPointerEvent(const ui::PointerEvent& event,
+                           const 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
@@ skipping 27 matching lines @@
   // 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);
+  DeepestWindow FindDeepestVisibleWindowForEvents(gfx::Point* location,
+                                                  int64_t* display_id);
 
   // 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 10 matching lines @@
   ClientSpecificId capture_window_client_id_;
 
   std::unique_ptr<DragController> drag_controller_;
 
   ModalWindowController modal_window_controller_;
 
   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.
+  // The location of the mouse pointer in display coordinates. This can be
+  // outside the bounds of |mouse_cursor_source_window_|, which can capture the
+  // cursor.
   gfx::Point mouse_pointer_last_location_;
+  // Id of the display |mouse_pointer_last_location_| is on.
+  int64_t mouse_pointer_display_id_ = 0;
+
+  // Id of the display the most recent event is on.

[sky, 2017/05/17 16:53:41]

Under what circumstances is mouse_pointer_display_id and event_dispaly_id_
different?

[riajiang, 2017/05/19 20:45:05]

We don't update mouse specific info (mouse_pointer_last_location_ and
mouse_pointer_display_id_) if the event coming in is not a mouse event, but
event_display_id_ would be changed in that case. 

+  int64_t event_display_id_ = 0;
 
   std::map<uint32_t, std::unique_ptr<Accelerator>> accelerators_;
 
   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_