More user id tracking for mus:

components/mus/ws/connection_manager.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_CONNECTION_MANAGER_H_
 #define COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
 #include "components/mus/public/interfaces/display.mojom.h"
 #include "components/mus/public/interfaces/window_manager_factory.mojom.h"
 #include "components/mus/public/interfaces/window_tree.mojom.h"
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/server_window_observer.h"
+#include "components/mus/ws/user_id_tracker.h"
 #include "components/mus/ws/window_manager_factory_registry.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "mojo/converters/surfaces/custom_surface_converter.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
 
 namespace mus {
 namespace ws {
@@ skipping 28 matching lines @@
 class ConnectionManager : public ServerWindowDelegate,
                           public ServerWindowObserver,
                           public mojom::DisplayManager {
  public:
   ConnectionManager(ConnectionManagerDelegate* delegate,
                     const scoped_refptr<mus::SurfacesState>& surfaces_state);
   ~ConnectionManager() override;
 
   ConnectionManagerDelegate* delegate() { return delegate_; }
 
+  UserIdTracker* user_id_tracker() { return &user_id_tracker_; }
+
   // Adds/removes a WindowTreeHost. ConnectionManager owns the
   // WindowTreeHostImpls.
   void AddHost(WindowTreeHostImpl* host);
   void DestroyHost(WindowTreeHostImpl* host);
+  std::set<WindowTreeHostImpl*> hosts() { return hosts_; }
 
   // Creates a new ServerWindow. The return value is owned by the caller, but
   // must be destroyed before ConnectionManager.
   ServerWindow* CreateServerWindow(
       const WindowId& id,
       const std::map<std::string, std::vector<uint8_t>>& properties);
 
   // Returns the id for the next WindowTreeImpl.
   ConnectionSpecificId GetAndAdvanceNextConnectionId();
 
@@ skipping 14 matching lines @@
   WindowTreeImpl* CreateTreeForWindowManager(
       WindowTreeHostImpl* host,
       mojom::WindowManagerFactory* factory,
       ServerWindow* root);
   // Invoked when a WindowTreeImpl's connection encounters an error.
   void DestroyTree(WindowTreeImpl* tree);
 
   // Returns the connection by id.
   WindowTreeImpl* GetConnection(ConnectionSpecificId connection_id);
 
+  size_t num_trees() const { return tree_map_.size(); }
+
   // Returns the Window identified by |id|.
   ServerWindow* GetWindow(const WindowId& id);
 
   // Schedules a paint for the specified region in the coordinates of |window|.
   void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
 
   OperationType current_operation_type() const {
     return current_operation_ ? current_operation_->type()
                               : OperationType::NONE;
   }
@@ skipping 32 matching lines @@
       const ServerWindow* window) const;
   WindowManagerAndHost GetWindowManagerAndHost(const ServerWindow* window);
 
   WindowTreeHostImpl* GetActiveWindowTreeHost();
 
   bool has_tree_host_connections() const { return !hosts_.empty(); }
 
   void AddDisplayManagerBinding(
       mojo::InterfaceRequest<mojom::DisplayManager> request);
 
-  void CreateWindowManagerFactoryService(
-      const uint32_t user_id,
-      mojo::InterfaceRequest<mojom::WindowManagerFactoryService> request);
-  void OnWindowManagerFactorySet();
+  void OnFirstWindowManagerFactorySet();
 
   WindowManagerFactoryRegistry* window_manager_factory_registry() {
     return &window_manager_factory_registry_;
   }
 
   // Returns a change id for the window manager that is associated with
   // |source| and |client_change_id|. When the window manager replies
   // WindowManagerChangeCompleted() is called to obtain the original source
   // and client supplied change_id that initiated the called.
   uint32_t GenerateWindowManagerChangeId(WindowTreeImpl* source,
@@ skipping 130 matching lines @@
   void OnWindowTextInputStateChanged(ServerWindow* window,
                                      const ui::TextInputState& state) override;
   void OnTransientWindowAdded(ServerWindow* window,
                               ServerWindow* transient_child) override;
   void OnTransientWindowRemoved(ServerWindow* window,
                                 ServerWindow* transient_child) override;
 
   // Overriden from mojom::DisplayManager:
   void AddObserver(mojom::DisplayManagerObserverPtr observer) override;
 
+  UserIdTracker user_id_tracker_;
+
   ConnectionManagerDelegate* delegate_;
 
   // State for rendering into a Surface.
   scoped_refptr<mus::SurfacesState> surfaces_state_;
 
   // ID to use for next WindowTreeImpl.
   ConnectionSpecificId next_connection_id_;
 
   // ID to use for next WindowTreeHostImpl.
   uint16_t next_host_id_;
@@ skipping 30 matching lines @@
 
   WindowManagerFactoryRegistry window_manager_factory_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_