mus Window Server: implement event capture

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 18 matching lines @@
 // 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; }
 
   void set_surface_id(cc::SurfaceId surface_id) { surface_id_ = surface_id; }
 
+  // |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_; }
+  void SetCaptureWindow(ServerWindow* capture_window, bool in_nonclient_area);
+
   // Retrieves the ServerWindow of the last mouse move.
   ServerWindow* mouse_cursor_source_window() const {
     return mouse_cursor_source_window_;
   }
 
   // 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();
 
   // 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.
   void ProcessEvent(mojom::EventPtr event);
 
  private:
+  friend class EventDispatcherTest;
+
   // Keeps track of state associated with an active pointer.
   struct PointerTarget {
     PointerTarget()
         : window(nullptr), in_nonclient_area(false), is_pointer_down(false) {}
 
     // NOTE: this is set to null if the window is destroyed before a
     // corresponding release/cancel.
     ServerWindow* window;
 
     // Did the pointer event start in the non-client area.
@@ skipping 58 matching lines @@
 
   // 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_;
 
+  bool capture_window_in_nonclient_area_;
   bool mouse_button_down_;
   ServerWindow* mouse_cursor_source_window_;
 
   // 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_;
 
   cc::SurfaceId surface_id_;
 
   using Entry = std::pair<uint32_t, EventMatcher>;
   std::map<uint32_t, EventMatcher> 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_;
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_