Changes ownership of WindowTreeHostConnection

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 20 matching lines @@
       next_connection_id_(1),
       next_host_id_(0),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       got_valid_frame_decorations_(false) {}
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
-  // Copy the HostConnectionMap because it will be mutated as the connections
-  // are closed.
-  HostConnectionMap host_connection_map(host_connection_map_);
-  for (auto& pair : host_connection_map)
-    pair.second->CloseConnection();
+  // 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(host_connection_map_.empty());
   DCHECK(connection_map_.empty());
 }
 
-void ConnectionManager::AddHost(WindowTreeHostConnection* host_connection) {
-  DCHECK_EQ(0u,
-            host_connection_map_.count(host_connection->window_tree_host()));
-  const bool is_first_connection = host_connection_map_.empty();
-  host_connection_map_[host_connection->window_tree_host()] = host_connection;
-  if (is_first_connection)
-    delegate_->OnFirstRootConnectionCreated();
+void ConnectionManager::AddHost(WindowTreeHostImpl* host) {
+  DCHECK_EQ(0u, pending_hosts_.count(host));
+  pending_hosts_.insert(host);
+}
+
+void ConnectionManager::DestroyHost(WindowTreeHostImpl* host) {
+  DCHECK(hosts_.count(host));
+  hosts_.erase(host);
+  delete host;
 }
 
 ServerWindow* ConnectionManager::CreateServerWindow(
     const WindowId& id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   ServerWindow* window = new ServerWindow(this, id, properties);
   window->AddObserver(this);
   return window;
 }
 
@@ skipping 44 matching lines @@
   }
   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()];
 }
 
-void ConnectionManager::OnHostConnectionClosed(
-    WindowTreeHostConnection* connection) {
-  auto it = host_connection_map_.find(connection->window_tree_host());
-  DCHECK(it != host_connection_map_.end());
+void ConnectionManager::OnHostConnectionClosed(WindowTreeHostImpl* host) {
+  if (pending_hosts_.count(host)) {
+    pending_hosts_.erase(host);
+    delete host;
+    return;
+  }
+  auto it = hosts_.find(host);
+  DCHECK(it != hosts_.end());
 
   // Get the ClientConnection by WindowTreeImpl ID.
   ConnectionMap::iterator service_connection_it =
-      connection_map_.find(it->first->GetWindowTree()->id());
+      connection_map_.find(host->GetWindowTree()->id());
   DCHECK(service_connection_it != connection_map_.end());
 
+  scoped_ptr<WindowTreeHostImpl> host_owner(*it);
+  hosts_.erase(it);
+
   // Tear down the associated WindowTree connection.
   // TODO(fsamuel): I don't think this is quite right, we should tear down all
   // connections within the root's viewport. We should probably employ an
   // observer pattern to do this. Each WindowTreeImpl should track its
   // parent's lifetime.
-  host_connection_map_.erase(it);
   OnConnectionError(service_connection_it->second);
 
-  for (auto& pair : connection_map_) {
-    pair.second->service()->OnWillDestroyWindowTreeHost(
-        connection->window_tree_host());
-  }
+  for (auto& pair : connection_map_)
+    pair.second->service()->OnWillDestroyWindowTreeHost(host);
 
   // If we have no more roots left, let the app know so it can terminate.
-  if (!host_connection_map_.size())
+  if (!hosts_.size() && !pending_hosts_.size())
     delegate_->OnNoMoreRootConnections();
 }
 
 WindowTreeImpl* ConnectionManager::EmbedAtWindow(
     ServerWindow* root,
     uint32_t policy_bitmask,
     mojom::WindowTreeClientPtr client) {
   mojom::WindowTreePtr tree_ptr;
   ClientConnection* client_connection =
       delegate_->CreateClientConnectionForEmbedAtWindow(
@@ skipping 12 matching lines @@
   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();
 }
 
 ServerWindow* ConnectionManager::GetWindow(const WindowId& id) {
-  for (auto& pair : host_connection_map_) {
-    if (pair.first->root_window()->id() == id)
-      return pair.first->root_window();
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (host->root_window()->id() == id)
+      return host->root_window();
   }
   WindowTreeImpl* service = GetConnection(id.connection_id);
   return service ? service->GetWindow(id) : nullptr;
 }
 
 bool ConnectionManager::IsWindowAttachedToRoot(
     const ServerWindow* window) const {
-  for (auto& pair : host_connection_map_) {
-    if (pair.first->IsWindowAttachedToRoot(window))
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (host->IsWindowAttachedToRoot(window))
       return true;
   }
   return false;
 }
 
 void ConnectionManager::SchedulePaint(const ServerWindow* window,
                                       const gfx::Rect& bounds) {
-  for (auto& pair : host_connection_map_) {
-    if (pair.first->SchedulePaintIfInViewport(window, bounds))
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (host->SchedulePaintIfInViewport(window, bounds))
       return;
   }
 }
 
+void ConnectionManager::OnWindowTreeHostDisplayAvailable(
+    WindowTreeHostImpl* host) {
+  DCHECK_NE(0u, pending_hosts_.count(host));
+  DCHECK_EQ(0u, hosts_.count(host));
+  const bool is_first_connection = hosts_.empty();
+  hosts_.insert(host);
+  pending_hosts_.erase(host);
+  if (is_first_connection)
+    delegate_->OnFirstRootConnectionCreated();
+}
+
 void ConnectionManager::OnConnectionMessagedClient(ConnectionSpecificId id) {
   if (current_operation_)
     current_operation_->MarkConnectionAsMessaged(id);
 }
 
 bool ConnectionManager::DidConnectionMessageClient(
     ConnectionSpecificId id) const {
   return current_operation_ && current_operation_->DidMessageConnection(id);
 }
 
 mojom::ViewportMetricsPtr ConnectionManager::GetViewportMetricsForWindow(
     const ServerWindow* window) {
   WindowTreeHostImpl* host = GetWindowTreeHostByWindow(window);
   if (host)
     return host->GetViewportMetrics().Clone();
 
-  if (!host_connection_map_.empty())
-    return host_connection_map_.begin()->first->GetViewportMetrics().Clone();
+  if (!hosts_.empty())
+    return (*hosts_.begin())->GetViewportMetrics().Clone();
 
   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();
   }
   return nullptr;
 }
 
 WindowTreeHostImpl* ConnectionManager::GetWindowTreeHostByWindow(
     const ServerWindow* window) {
   return const_cast<WindowTreeHostImpl*>(
       static_cast<const ConnectionManager*>(this)
           ->GetWindowTreeHostByWindow(window));
 }
 
 const WindowTreeHostImpl* ConnectionManager::GetWindowTreeHostByWindow(
     const ServerWindow* window) const {
   while (window && window->parent())
     window = window->parent();
-  for (auto& pair : host_connection_map_) {
-    if (window == pair.first->root_window())
-      return pair.first;
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (window == host->root_window())
+      return host;
   }
   return nullptr;
 }
 
 WindowTreeHostImpl* ConnectionManager::GetActiveWindowTreeHost() {
-  return host_connection_map_.begin()->first;
+  // TODO(sky): this isn't active, but first. Make it active.
+  return hosts_.size() ? *hosts_.begin() : nullptr;
 }
 
 void ConnectionManager::AddDisplayManagerBinding(
     mojo::InterfaceRequest<mojom::DisplayManager> request) {
   display_manager_bindings_.AddBinding(this, std::move(request));
 }
 
 void ConnectionManager::CreateWindowManagerFactoryService(
     mojo::InterfaceRequest<mojom::WindowManagerFactoryService> request) {
   if (window_manager_factory_service_)
@@ skipping 194 matching lines @@
 
 void ConnectionManager::MaybeUpdateNativeCursor(ServerWindow* window) {
   // This can be null in unit tests.
   WindowTreeHostImpl* impl = GetWindowTreeHostByWindow(window);
   if (impl)
     impl->MaybeChangeCursorOnWindowTreeChange();
 }
 
 void ConnectionManager::CallOnDisplays(
     mojom::DisplayManagerObserver* observer) {
-  mojo::Array<mojom::DisplayPtr> displays(host_connection_map_.size());
+  mojo::Array<mojom::DisplayPtr> displays(hosts_.size());
   {
     size_t i = 0;
-    for (auto& pair : host_connection_map_) {
-      displays[i] = DisplayForHost(pair.first);
+    // TODO(sky): need ordering!
+    for (WindowTreeHostImpl* host : hosts_) {
+      displays[i] = DisplayForHost(host);
       ++i;
     }
   }
   observer->OnDisplays(std::move(displays));
 }
 
 void ConnectionManager::CallOnDisplayChanged(
     mojom::DisplayManagerObserver* observer,
     WindowTreeHostImpl* host) {
   mojo::Array<mojom::DisplayPtr> displays(1);
   displays[0] = DisplayForHost(host);
   display_manager_observers_.ForAllPtrs(
       [&displays](mojom::DisplayManagerObserver* observer) {
         observer->OnDisplaysChanged(displays.Clone());
       });
 }
 
 mojom::DisplayPtr ConnectionManager::DisplayForHost(WindowTreeHostImpl* host) {
   size_t i = 0;
   int next_x = 0;
-  for (auto& pair : host_connection_map_) {
+  for (WindowTreeHostImpl* host2 : hosts_) {
     const ServerWindow* root = host->root_window();
-    if (pair.first == host) {
+    if (host == host2) {
       mojom::DisplayPtr display = mojom::Display::New();
       display = mojom::Display::New();
       display->id = host->id();
       display->bounds = mojo::Rect::New();
       display->bounds->x = next_x;
       display->bounds->y = 0;
       display->bounds->width = root->bounds().size().width();
       display->bounds->height = root->bounds().size().height();
       // TODO(sky): window manager needs an API to set the work area.
       display->work_area = display->bounds.Clone();
@@ skipping 24 matching lines @@
     SchedulePaint(window, gfx::Rect(window->bounds().size()));
 }
 
 const ServerWindow* ConnectionManager::GetRootWindow(
     const ServerWindow* window) const {
   const WindowTreeHostImpl* host = GetWindowTreeHostByWindow(window);
   return host ? host->root_window() : nullptr;
 }
 
 void ConnectionManager::ScheduleSurfaceDestruction(ServerWindow* window) {
-  for (auto& pair : host_connection_map_) {
-    if (pair.first->root_window()->Contains(window)) {
-      pair.first->ScheduleSurfaceDestruction(window);
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (host->root_window()->Contains(window)) {
+      host->ScheduleSurfaceDestruction(window);
       break;
     }
   }
 }
 
 ServerWindow* ConnectionManager::FindWindowForSurface(
     const ServerWindow* ancestor,
     mojom::SurfaceType surface_type,
     const ClientWindowId& client_window_id) {
   WindowTreeImpl* window_tree;
@@ skipping 150 matching lines @@
   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