Changes ownership of WindowTreeHostConnection

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>
@@ skipping 35 matching lines @@
 // 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;
 
-  // Adds a WindowTreeHost.
-  void AddHost(WindowTreeHostConnection* connection);
+  // 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);
 
-  // Invoked when a WindowTreeHostConnection encounters an error or the
-  // associated Display window is closed.
-  void OnHostConnectionClosed(WindowTreeHostConnection* connection);
+  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);
@@ skipping 12 matching lines @@
   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();
 
+  // Called when the AcceleratedWidget is available for |host|.
+  void OnWindowTreeHostDisplayAvailable(WindowTreeHostImpl* host);
+
   // Invoked when a connection messages a client about the change. This is used
   // to avoid sending ServerChangeIdAdvanced() unnecessarily.
   void OnConnectionMessagedClient(ConnectionSpecificId id);
 
   // Returns true if OnConnectionMessagedClient() was invoked for id.
   bool DidConnectionMessageClient(ConnectionSpecificId id) const;
 
   // Returns the metrics of the viewport where the provided |window| is
   // displayed.
   mojom::ViewportMetricsPtr GetViewportMetricsForWindow(
       const ServerWindow* window);
 
   // Returns the WindowTreeImpl that has |id| as a root.
   WindowTreeImpl* GetConnectionWithRoot(const ServerWindow* window) {
     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;
 
   WindowTreeHostImpl* GetActiveWindowTreeHost();
 
-  bool has_tree_host_connections() const {
-    return !host_connection_map_.empty();
-  }
+  bool has_tree_host_connections() const { return !hosts_.empty(); }
 
   void AddDisplayManagerBinding(
       mojo::InterfaceRequest<mojom::DisplayManager> request);
 
   void CreateWindowManagerFactoryService(
       mojo::InterfaceRequest<mojom::WindowManagerFactoryService> request);
 
   // 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
@@ skipping 146 matching lines @@
 
   // ID to use for next WindowTreeImpl.
   ConnectionSpecificId next_connection_id_;
 
   // ID to use for next WindowTreeHostImpl.
   uint16_t next_host_id_;
 
   // Set of WindowTreeImpls.
   ConnectionMap connection_map_;
 
-  // Set of WindowTreeHostImpls.
-  HostConnectionMap host_connection_map_;
+  // WindowTreeHostImpls are initially added to |pending_hosts_|. When the
+  // display is initialized it is moved to |hosts_|.
+  // ConnectionManager owns the WindowTreeHostImpls.
+  std::set<WindowTreeHostImpl*> pending_hosts_;
+  std::set<WindowTreeHostImpl*> hosts_;
 
   // If non-null then we're processing a client operation. The Operation is
   // not owned by us (it's created on the stack by WindowTreeImpl).
   Operation* current_operation_;
 
   bool in_destructor_;
 
   // Maps from window manager change id to the client that initiated the
   // request.
   InFlightWindowManagerChangeMap in_flight_wm_change_map_;
@@ skipping 11 matching lines @@
 
   scoped_ptr<WindowManagerFactoryService> window_manager_factory_service_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionManager);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_CONNECTION_MANAGER_H_