Changes ownership of ClientConnection

components/mus/ws/connection_manager.cc

 // 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.
 
 #include "components/mus/ws/connection_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/client_connection.h"
 #include "components/mus/ws/connection_manager_delegate.h"
@@ skipping 31 matching lines @@
 
   while (!pending_hosts_.empty())
     DestroyHost(*pending_hosts_.begin());
   DCHECK(pending_hosts_.empty());
 
   // DestroyHost() removes from |hosts_| and deletes the WindowTreeHostImpl.
   while (!hosts_.empty())
     DestroyHost(*hosts_.begin());
   DCHECK(hosts_.empty());
 
-  STLDeleteValues(&connection_map_);
-  // All the connections should have been destroyed.
-  DCHECK(connection_map_.empty());
+  tree_map_.clear();
 }
 
 void ConnectionManager::AddHost(WindowTreeHostImpl* host) {
   DCHECK_EQ(0u, pending_hosts_.count(host));
   pending_hosts_.insert(host);
 }
 
 void ConnectionManager::DestroyHost(WindowTreeHostImpl* host) {
-  for (auto& pair : connection_map_)
-    pair.second->service()->OnWillDestroyWindowTreeHost(host);
+  for (auto& pair : tree_map_)
+    pair.second->OnWillDestroyWindowTreeHost(host);
 
   if (pending_hosts_.count(host)) {
     pending_hosts_.erase(host);
   } else {
     DCHECK(hosts_.count(host));
     hosts_.erase(host);
   }
   delete host;
 
   // If we have no more roots left, let the app know so it can terminate.
@@ skipping 14 matching lines @@
   DCHECK_LT(id, next_connection_id_);
   return id;
 }
 
 uint16_t ConnectionManager::GetAndAdvanceNextHostId() {
   const uint16_t id = next_host_id_++;
   DCHECK_LT(id, next_host_id_);
   return id;
 }
 
-void ConnectionManager::OnConnectionError(ClientConnection* connection) {
-  for (auto* root : connection->service()->roots()) {
-    // If the WindowTree root is a viewport root, then we'll wait until
-    // the root connection goes away to cleanup.
-    if (GetRootWindow(root) == root)
-      return;
+WindowTreeImpl* ConnectionManager::EmbedAtWindow(
+    ServerWindow* root,
+    uint32_t policy_bitmask,
+    mojom::WindowTreeClientPtr client) {
+  scoped_ptr<WindowTreeImpl> tree_ptr(
+      new ws::WindowTreeImpl(this, root, policy_bitmask));
+  WindowTreeImpl* tree = tree_ptr.get();
+
+  mojom::WindowTreePtr window_tree_ptr;
+  scoped_ptr<ClientConnection> client_connection =
+      delegate_->CreateClientConnectionForEmbedAtWindow(
+          this, tree, GetProxy(&window_tree_ptr), std::move(client));
+
+  AddTree(std::move(tree_ptr), std::move(client_connection),
+          std::move(window_tree_ptr));
+  OnConnectionMessagedClient(tree->id());
+  return tree;
+}
+
+WindowTreeImpl* ConnectionManager::AddTree(
+    scoped_ptr<WindowTreeImpl> tree_impl_ptr,
+    scoped_ptr<ClientConnection> connection,
+    mojom::WindowTreePtr tree_ptr) {
+  CHECK_EQ(0u, tree_map_.count(tree_impl_ptr->id()));
+  WindowTreeImpl* tree = tree_impl_ptr.get();
+  tree_map_[tree->id()] = std::move(tree_impl_ptr);
+  tree->Init(std::move(connection), std::move(tree_ptr));
+  return tree;
+}
+
+WindowTreeImpl* ConnectionManager::CreateTreeForWindowManager(
+    WindowTreeHostImpl* host,
+    mojom::WindowManagerFactory* factory,
+    ServerWindow* root) {
+  mojom::DisplayPtr display = DisplayForHost(host);
+  mojom::WindowTreeClientPtr tree_client;
+  factory->CreateWindowManager(std::move(display), GetProxy(&tree_client));
+  scoped_ptr<ws::WindowTreeImpl> tree_ptr(new ws::WindowTreeImpl(
+      this, root, mojom::WindowTree::kAccessPolicyEmbedRoot));
+  ws::WindowTreeImpl* tree = tree_ptr.get();
+  scoped_ptr<ws::DefaultClientConnection> connection(
+      new ws::DefaultClientConnection(tree_ptr.get(), this,
+                                      std::move(tree_client)));
+  mojom::WindowTreePtr window_tree_ptr =
+      connection->CreateInterfacePtrAndBind();
+  AddTree(std::move(tree_ptr), std::move(connection),
+          std::move(window_tree_ptr));
+  tree->ConfigureWindowManager();
+  return tree;
+}
+
+void ConnectionManager::DestroyTree(WindowTreeImpl* tree) {
+  scoped_ptr<WindowTreeImpl> tree_ptr;
+  {
+    auto iter = tree_map_.find(tree->id());
+    DCHECK(iter != tree_map_.end());
+    tree_ptr = std::move(iter->second);
+    tree_map_.erase(iter);
   }
 
-  scoped_ptr<ClientConnection> connection_owner(connection);
-
-  connection_map_.erase(connection->service()->id());
-
   // Notify remaining connections so that they can cleanup.
-  for (auto& pair : connection_map_)
-    pair.second->service()->OnWindowDestroyingTreeImpl(connection->service());
+  for (auto& pair : tree_map_)
+    pair.second->OnWindowDestroyingTreeImpl(tree);
 
   // Notify the hosts, taking care to only notify each host once.
   std::set<WindowTreeHostImpl*> hosts_notified;
-  for (auto* root : connection->service()->roots()) {
+  for (auto* root : tree->roots()) {
     WindowTreeHostImpl* host = GetWindowTreeHostByWindow(root);
     if (host && hosts_notified.count(host) == 0) {
-      host->OnWindowTreeConnectionError(connection->service());
+      host->OnWindowTreeConnectionError(tree);
       hosts_notified.insert(host);
     }
   }
 
   // Remove any requests from the client that resulted in a call to the window
   // manager and we haven't gotten a response back yet.
   std::set<uint32_t> to_remove;
   for (auto& pair : in_flight_wm_change_map_) {
-    if (pair.second.connection_id == connection->service()->id())
+    if (pair.second.connection_id == tree->id())
       to_remove.insert(pair.first);
   }
   for (uint32_t id : to_remove)
     in_flight_wm_change_map_.erase(id);
 }
 
-ClientConnection* ConnectionManager::GetClientConnection(
-    WindowTreeImpl* window_tree) {
-  return connection_map_[window_tree->id()];
-}
-
-WindowTreeImpl* ConnectionManager::EmbedAtWindow(
-    ServerWindow* root,
-    uint32_t policy_bitmask,
-    mojom::WindowTreeClientPtr client) {
-  mojom::WindowTreePtr tree_ptr;
-  ClientConnection* client_connection =
-      delegate_->CreateClientConnectionForEmbedAtWindow(
-          this, GetProxy(&tree_ptr), root, policy_bitmask, std::move(client));
-  AddConnection(make_scoped_ptr(client_connection), std::move(tree_ptr));
-  OnConnectionMessagedClient(client_connection->service()->id());
-  return client_connection->service();
-}
-
-void ConnectionManager::AddConnection(
-    scoped_ptr<ClientConnection> owned_connection,
-    mojom::WindowTreePtr tree_ptr) {
-  ClientConnection* connection = owned_connection.release();
-  CHECK_EQ(0u, connection_map_.count(connection->service()->id()));
-  connection_map_[connection->service()->id()] = connection;
-  connection->service()->Init(connection->client(), std::move(tree_ptr));
-}
-
 WindowTreeImpl* ConnectionManager::GetConnection(
     ConnectionSpecificId connection_id) {
-  ConnectionMap::iterator i = connection_map_.find(connection_id);
-  return i == connection_map_.end() ? nullptr : i->second->service();
+  auto iter = tree_map_.find(connection_id);
+  return iter == tree_map_.end() ? nullptr : iter->second.get();
 }
 
 ServerWindow* ConnectionManager::GetWindow(const WindowId& id) {
   // kInvalidConnectionId is used for WindowTreeHost and WindowManager root
   // nodes.
   if (id.connection_id == kInvalidConnectionId) {
     for (WindowTreeHostImpl* host : hosts_) {
       ServerWindow* window = host->GetRootWithId(id);
       if (window)
         return window;
@@ skipping 43 matching lines @@
 
   mojom::ViewportMetricsPtr metrics = mojom::ViewportMetrics::New();
   metrics->size_in_pixels = mojo::Size::New();
   return metrics;
 }
 
 const WindowTreeImpl* ConnectionManager::GetConnectionWithRoot(
     const ServerWindow* window) const {
   if (!window)
     return nullptr;
-  for (auto& pair : connection_map_) {
-    if (pair.second->service()->HasRoot(window))
-      return pair.second->service();
+  for (auto& pair : tree_map_) {
+    if (pair.second->HasRoot(window))
+      return pair.second.get();
   }
   return nullptr;
 }
 
 WindowManagerAndHostConst ConnectionManager::GetWindowManagerAndHost(
     const ServerWindow* window) const {
   const ServerWindow* last = window;
   while (window && window->parent()) {
     last = window;
     window = window->parent();
@@ skipping 146 matching lines @@
     ++i;
   }
   NOTREACHED();
   return mojom::Display::New();
 }
 
 void ConnectionManager::ProcessWindowBoundsChanged(
     const ServerWindow* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWindowBoundsChanged(
-        window, old_bounds, new_bounds, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWindowBoundsChanged(window, old_bounds, new_bounds,
+                                            IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessClientAreaChanged(
     const ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessClientAreaChanged(
-        window, new_client_area, new_additional_client_areas,
-        IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessClientAreaChanged(window, new_client_area,
+                                          new_additional_client_areas,
+                                          IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessLostCapture(const ServerWindow* window) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessLostCapture(window,
-                                               IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessLostCapture(window, IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessWillChangeWindowHierarchy(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWillChangeWindowHierarchy(
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWillChangeWindowHierarchy(
         window, new_parent, old_parent, IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessWindowHierarchyChanged(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWindowHierarchyChanged(
-        window, new_parent, old_parent, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWindowHierarchyChanged(window, new_parent, old_parent,
+                                               IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessWindowReorder(
     const ServerWindow* window,
     const ServerWindow* relative_window,
     const mojom::OrderDirection direction) {
   // We'll probably do a bit of reshuffling when we add a transient window.
   if ((current_operation_type() == OperationType::ADD_TRANSIENT_WINDOW) ||
       (current_operation_type() ==
        OperationType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT)) {
     return;
   }
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWindowReorder(
-        window, relative_window, direction, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWindowReorder(window, relative_window, direction,
+                                      IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessWindowDeleted(const ServerWindow* window) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWindowDeleted(window,
-                                                 IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWindowDeleted(window, IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::ProcessWillChangeWindowPredefinedCursor(
     ServerWindow* window,
     int32_t cursor_id) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessCursorChanged(window, cursor_id,
-                                                 IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessCursorChanged(window, cursor_id,
+                                      IsOperationSource(pair.first));
   }
 
   // Pass the cursor change to the native window.
   WindowTreeHostImpl* host = GetWindowTreeHostByWindow(window);
   if (host)
     host->OnCursorUpdated(window);
 }
 
 void ConnectionManager::ProcessViewportMetricsChanged(
     WindowTreeHostImpl* host,
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessViewportMetricsChanged(
-        host, old_metrics, new_metrics, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessViewportMetricsChanged(host, old_metrics, new_metrics,
+                                               IsOperationSource(pair.first));
   }
 
   if (!got_valid_frame_decorations_)
     return;
 }
 
 void ConnectionManager::ProcessFrameDecorationValuesChanged(
     WindowTreeHostImpl* host) {
   if (!got_valid_frame_decorations_) {
     got_valid_frame_decorations_ = true;
@@ skipping 188 matching lines @@
     return;
 
   // Need to repaint if the window was drawn (which means it's in the process of
   // hiding) or the window is transitioning to drawn.
   if (window->parent() &&
       (window->IsDrawn() ||
        (!window->visible() && window->parent()->IsDrawn()))) {
     SchedulePaint(window->parent(), window->bounds());
   }
 
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWillChangeWindowVisibility(
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWillChangeWindowVisibility(
         window, IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::OnWindowPredefinedCursorChanged(ServerWindow* window,
                                                         int32_t cursor_id) {
   if (in_destructor_)
     return;
 
   ProcessWillChangeWindowPredefinedCursor(window, cursor_id);
 }
 
 void ConnectionManager::OnWindowSharedPropertyChanged(
     ServerWindow* window,
     const std::string& name,
     const std::vector<uint8_t>* new_data) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessWindowPropertyChanged(
-        window, name, new_data, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessWindowPropertyChanged(window, name, new_data,
+                                              IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::OnWindowTextInputStateChanged(
     ServerWindow* window,
     const ui::TextInputState& state) {
   WindowTreeHostImpl* host = GetWindowTreeHostByWindow(window);
   host->UpdateTextInputState(window, state);
 }
 
 void ConnectionManager::OnTransientWindowAdded(ServerWindow* window,
                                                ServerWindow* transient_child) {
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessTransientWindowAdded(
-        window, transient_child, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessTransientWindowAdded(window, transient_child,
+                                             IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::OnTransientWindowRemoved(
     ServerWindow* window,
     ServerWindow* transient_child) {
   // If we're deleting a window, then this is a superfluous message.
   if (current_operation_type() == OperationType::DELETE_WINDOW)
     return;
-  for (auto& pair : connection_map_) {
-    pair.second->service()->ProcessTransientWindowRemoved(
-        window, transient_child, IsOperationSource(pair.first));
+  for (auto& pair : tree_map_) {
+    pair.second->ProcessTransientWindowRemoved(window, transient_child,
+                                               IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::AddObserver(mojom::DisplayManagerObserverPtr observer) {
   // TODO(sky): this needs to be per user.
 
   // Many clients key off the frame decorations to size widgets. Wait for frame
   // decorations before notifying so that we don't have to worry about clients
   // resizing appropriately.
   if (!got_valid_frame_decorations_) {
     display_manager_observers_.AddInterfacePtr(std::move(observer));
     return;
   }
   CallOnDisplays(observer.get());
   display_manager_observers_.AddInterfacePtr(std::move(observer));
 }
 
 }  // namespace ws
 }  // namespace mus