mus: Add EventObserver to allow passively listening to UI events

components/mus/ws/window_tree.h

 // Copyright 2014 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_WINDOW_TREE_H_
 #define COMPONENTS_MUS_WS_WINDOW_TREE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 21 matching lines @@
 namespace ui {
 class Event;
 }
 
 namespace mus {
 namespace ws {
 
 class AccessPolicy;
 class DisplayManager;
 class Display;
+class EventMatcher;
 class ServerWindow;
 class TargetedEvent;
 class WindowManagerState;
 class WindowServer;
 class WindowTreeTest;
 
 namespace test {
 class WindowTreeTestApi;
 }
 
@@ skipping 152 matching lines @@
                            const ServerWindow* new_focused_window);
   void ProcessLostCapture(const ServerWindow* old_lost_capture,
                           bool originated_change);
   void ProcessTransientWindowAdded(const ServerWindow* window,
                                    const ServerWindow* transient_window,
                                    bool originated_change);
   void ProcessTransientWindowRemoved(const ServerWindow* window,
                                      const ServerWindow* transient_window,
                                      bool originated_change);
 
+  // Sends this event to the client if it matches an active event observer.
+  void SendToEventObserver(const ui::Event& event);
+
  private:
   friend class test::WindowTreeTestApi;
 
   struct WaitingForTopLevelWindowInfo {
     WaitingForTopLevelWindowInfo(const ClientWindowId& client_window_id,
                                  uint32_t wm_change_id)
         : client_window_id(client_window_id), wm_change_id(wm_change_id) {}
     ~WaitingForTopLevelWindowInfo() {}
 
     // Id supplied from the client.
@@ skipping 108 matching lines @@
   void ReorderWindow(uint32_t change_Id,
                      Id window_id,
                      Id relative_window_id,
                      mojom::OrderDirection direction) override;
   void GetWindowTree(
       Id window_id,
       const mojo::Callback<void(mojo::Array<mojom::WindowDataPtr>)>& callback)
       override;
   void SetCapture(uint32_t change_id, Id window_id) override;
   void ReleaseCapture(uint32_t change_id, Id window_id) override;
+  void SetEventObserver(mojom::EventMatcherPtr matcher,
+                        uint32_t observer_id) override;
   void SetWindowBounds(uint32_t change_id,
                        Id window_id,
                        mojo::RectPtr bounds) override;
   void SetWindowVisibility(uint32_t change_id,
                            Id window_id,
                            bool visible) override;
   void SetWindowProperty(uint32_t change_id,
                          Id transport_window_id,
                          const mojo::String& name,
                          mojo::Array<uint8_t> value) override;
@@ skipping 48 matching lines @@
                                  Id transport_window_id) override;
 
   // AccessPolicyDelegate:
   bool HasRootForAccessPolicy(const ServerWindow* window) const override;
   bool IsWindowKnownForAccessPolicy(const ServerWindow* window) const override;
   bool IsWindowRootOfAnotherTreeForAccessPolicy(
       const ServerWindow* window) const override;
 
   WindowServer* window_server_;
 
-  const UserId user_id_;
+  UserId user_id_;
 
   // Id of this tree as assigned by WindowServer.
   const ConnectionSpecificId id_;
   std::string connection_name_;
 
   ConnectionSpecificId next_window_id_;
 
   std::unique_ptr<WindowTreeBinding> binding_;
 
   std::unique_ptr<mus::ws::AccessPolicy> access_policy_;
 
   // The roots, or embed points, of this tree. A WindowTree may have any
   // number of roots, including 0.
   std::set<const ServerWindow*> roots_;
 
   // The windows created by this tree. This tree owns these objects.
   base::hash_map<WindowId, ServerWindow*> created_window_map_;
 
   // The client is allowed to assign ids. These two maps providing the mapping
   // from the ids native to the server (WindowId) to those understood by the
   // client (ClientWindowId).
   base::hash_map<ClientWindowId, WindowId> client_id_to_window_id_map_;
   base::hash_map<WindowId, ClientWindowId> window_id_to_client_id_map_;
 
   uint32_t event_ack_id_;
 
+  // Set when the client is using SetEventObserver() to observe events,
+  // otherwise null.
+  std::unique_ptr<EventMatcher> event_observer_matcher_;
+
+  // The ID supplied by the client for the current event observer.
+  uint32_t event_observer_id_ = 0;
+
   // WindowManager the current event came from.
   WindowManagerState* event_source_wms_ = nullptr;
 
   std::queue<std::unique_ptr<TargetedEvent>> event_queue_;
 
   std::unique_ptr<mojo::AssociatedBinding<mojom::WindowManagerClient>>
       window_manager_internal_client_binding_;
   mojom::WindowManager* window_manager_internal_;
 
   std::unique_ptr<WaitingForTopLevelWindowInfo>
       waiting_for_top_level_window_info_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowTree);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_WINDOW_TREE_H_