Promotes remaining global window manager state into WindowManagerState

components/mus/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 COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_
 #define COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 23 matching lines @@
 namespace test {
 class EventDispatcherTestApi;
 }
 
 // Handles dispatching events to the right location as well as updating focus.
 class EventDispatcher : public ServerWindowObserver {
  public:
   explicit EventDispatcher(EventDispatcherDelegate* delegate);
   ~EventDispatcher() override;
 
-  void set_root(ServerWindow* root) { root_ = root; }
-
   // 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);
   const gfx::Point& mouse_pointer_last_location() const {
     return mouse_pointer_last_location_;
   }
 
   // If we still have the window of the last mouse move, returns true and sets
@@ skipping 100 matching lines @@
   // 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);
 
   // Returns a PointerTarget from the supplied event.
-  PointerTarget PointerTargetForEvent(const ui::LocatedEvent& event) const;
+  PointerTarget PointerTargetForEvent(const ui::LocatedEvent& event);
 
   // 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);
 
+  ServerWindow* FindDeepestVisibleWindowForEvents(gfx::Point* location);
+
   // ServerWindowObserver:
   void OnWillChangeWindowHierarchy(ServerWindow* window,
                                    ServerWindow* new_parent,
                                    ServerWindow* old_parent) override;
   void OnWindowVisibilityChanged(ServerWindow* window) override;
   void OnWindowDestroyed(ServerWindow* window) override;
 
   EventDispatcherDelegate* delegate_;
-  ServerWindow* root_;
 
   ServerWindow* capture_window_;
   ClientSpecificId capture_window_client_id_;
 
   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.
   gfx::Point mouse_pointer_last_location_;
 
-  using Entry = std::pair<uint32_t, std::unique_ptr<Accelerator>>;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_