Adds WindowManagerManager to 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/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 {
 
 class ClientConnection;
 class ConnectionManagerDelegate;
 class ServerWindow;
-class WindowManagerFactoryService;
+class WindowManagerState;
 class WindowTreeHostConnection;
 class WindowTreeImpl;
 
+struct WindowManagerAndHost {
+  WindowManagerAndHost()
+      : window_manager_state(nullptr), window_tree_host(nullptr) {}
+
+  WindowManagerState* window_manager_state;
+  WindowTreeHostImpl* window_tree_host;
+};
+
+struct WindowManagerAndHostConst {
+  WindowManagerAndHostConst()
+      : window_manager_state(nullptr), window_tree_host(nullptr) {}
+  const WindowManagerState* window_manager_state;
+  const WindowTreeHostImpl* window_tree_host;
+};
+
 // ConnectionManager manages the set of connections to the window server (all
 // the WindowTreeImpls) as well as providing the root of the hierarchy.
 //
 // TODO(sky): this class is doing too much. Refactor to make responsibilities
 // clearer.
 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_; }
+
   // Adds/removes a WindowTreeHost. ConnectionManager owns the
   // WindowTreeHostImpls.
   void AddHost(WindowTreeHostImpl* host);
   void DestroyHost(WindowTreeHostImpl* host);
 
   // 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();
 
   // Returns the id for the next WindowTreeHostImpl.
   uint16_t GetAndAdvanceNextHostId();
 
   // Invoked when a WindowTreeImpl's connection encounters an error.
   void OnConnectionError(ClientConnection* connection);
 
   ClientConnection* GetClientConnection(WindowTreeImpl* window_tree);
 
-  void OnHostConnectionClosed(WindowTreeHostImpl* host);
-
   // See description of WindowTree::Embed() for details. This assumes
   // |transport_window_id| is valid.
   WindowTreeImpl* EmbedAtWindow(ServerWindow* root,
                                 uint32_t policy_bitmask,
                                 mojom::WindowTreeClientPtr client);
 
   // Adds |connection| to internal maps.
   void AddConnection(scoped_ptr<ClientConnection> owned_connection,
                      mojom::WindowTreePtr tree_ptr);
 
   // Returns the connection by id.
   WindowTreeImpl* GetConnection(ConnectionSpecificId connection_id);
 
   // Returns the Window identified by |id|.
   ServerWindow* GetWindow(const WindowId& id);
 
-  // Returns whether |window| is a descendant of some root window but not itself
-  // a root window.
-  bool IsWindowAttachedToRoot(const ServerWindow* window) const;
-
   // 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;
   }
 
   // Invoked when the WindowTreeHostImpl's display is closed.
   void OnDisplayClosed();
@@ skipping 18 matching lines @@
     return const_cast<WindowTreeImpl*>(
         const_cast<const ConnectionManager*>(this)
             ->GetConnectionWithRoot(window));
   }
   const WindowTreeImpl* GetConnectionWithRoot(const ServerWindow* window) const;
 
   WindowTreeHostImpl* GetWindowTreeHostByWindow(const ServerWindow* window);
   const WindowTreeHostImpl* GetWindowTreeHostByWindow(
       const ServerWindow* window) const;
 
+  WindowManagerAndHostConst GetWindowManagerAndHost(
+      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();
+
+  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,
                                          uint32_t client_change_id);
 
   // Called when a response from the window manager is obtained. Calls to
   // the client that initiated the change with the change id originally
   // supplied by the client.
   void WindowManagerChangeCompleted(uint32_t window_manager_change_id,
                                     bool success);
   void WindowManagerCreatedTopLevelWindow(WindowTreeImpl* wm_connection,
                                           uint32_t window_manager_change_id,
                                           const ServerWindow* window);
 
   // Called when we get an unexpected message from the WindowManager.
   // TODO(sky): decide what we want to do here.
   void WindowManagerSentBogusMessage() {}
 
+  // Returns the Display for |host|.
+  mojom::DisplayPtr DisplayForHost(WindowTreeHostImpl* host);
+
   // These functions trivially delegate to all WindowTreeImpls, which in
   // term notify their clients.
-  void ProcessWindowDestroyed(ServerWindow* window);
   void ProcessWindowBoundsChanged(const ServerWindow* window,
                                   const gfx::Rect& old_bounds,
                                   const gfx::Rect& new_bounds);
   void ProcessClientAreaChanged(
       const ServerWindow* window,
       const gfx::Insets& new_client_area,
       const std::vector<gfx::Rect>& new_additional_client_areas);
   void ProcessLostCapture(const ServerWindow* window);
   void ProcessViewportMetricsChanged(WindowTreeHostImpl* host,
                                      const mojom::ViewportMetrics& old_metrics,
@@ skipping 54 matching lines @@
   // Run in response to events which may cause us to change the native cursor.
   void MaybeUpdateNativeCursor(ServerWindow* window);
 
   // Calls OnDisplays() on |observer|.
   void CallOnDisplays(mojom::DisplayManagerObserver* observer);
 
   // Calls observer->OnDisplaysChanged() with the display for |host|.
   void CallOnDisplayChanged(mojom::DisplayManagerObserver* observer,
                             WindowTreeHostImpl* host);
 
-  // Returns the Display for |host|.
-  mojom::DisplayPtr DisplayForHost(WindowTreeHostImpl* host);
-
   // Overridden from ServerWindowDelegate:
   mus::SurfacesState* GetSurfacesState() override;
   void OnScheduleWindowPaint(const ServerWindow* window) override;
   const ServerWindow* GetRootWindow(const ServerWindow* window) const override;
   void ScheduleSurfaceDestruction(ServerWindow* window) override;
   ServerWindow* FindWindowForSurface(
       const ServerWindow* ancestor,
       mojom::SurfaceType surface_type,
       const ClientWindowId& client_window_id) override;
 
@@ skipping 66 matching lines @@
   uint32_t next_wm_change_id_;
 
   mojo::BindingSet<mojom::DisplayManager> display_manager_bindings_;
   // WARNING: only use these once |got_valid_frame_decorations_| is true.
   // TODO(sky): refactor this out into its own class.
   mojo::InterfacePtrSet<mojom::DisplayManagerObserver>
       display_manager_observers_;
 
   bool got_valid_frame_decorations_;
 
-  scoped_ptr<WindowManagerFactoryService> window_manager_factory_service_;
+  WindowManagerFactoryRegistry window_manager_factory_registry_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_