Adds WindowManagerManager to mus

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"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_manager_factory_service.h"
+#include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree_host_connection.h"
 #include "components/mus/ws/window_tree_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/shell/public/cpp/connection.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace mus {
 namespace ws {
 
 ConnectionManager::ConnectionManager(
     ConnectionManagerDelegate* delegate,
     const scoped_refptr<mus::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_connection_id_(1),
       next_host_id_(0),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
-      got_valid_frame_decorations_(false) {}
+      got_valid_frame_decorations_(false),
+      window_manager_factory_registry_(this) {}
 
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
+  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());
 }
 
 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);
+  for (auto& pair : connection_map_)
+    pair.second->service()->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.
+  if (!hosts_.size() && !pending_hosts_.size())
+    delegate_->OnNoMoreRootConnections();
 }
 
 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(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(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.
-  OnConnectionError(service_connection_it->second);
-
-  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 (!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(
           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();
 }
 
 ServerWindow* ConnectionManager::GetWindow(const WindowId& id) {
-  for (WindowTreeHostImpl* host : hosts_) {
-    if (host->root_window()->id() == id)
-      return host->root_window();
+  // 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;
+    }
   }
   WindowTreeImpl* service = GetConnection(id.connection_id);
   return service ? service->GetWindow(id) : nullptr;
 }
 
-bool ConnectionManager::IsWindowAttachedToRoot(
-    const ServerWindow* window) const {
-  for (WindowTreeHostImpl* host : hosts_) {
-    if (host->IsWindowAttachedToRoot(window))
-      return true;
-  }
-  return false;
-}
-
 void ConnectionManager::SchedulePaint(const ServerWindow* window,
                                       const gfx::Rect& bounds) {
   for (WindowTreeHostImpl* host : hosts_) {
     if (host->SchedulePaintIfInViewport(window, bounds))
       return;
   }
 }
 
 void ConnectionManager::OnWindowTreeHostDisplayAvailable(
     WindowTreeHostImpl* host) {
@@ skipping 34 matching lines @@
     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;
 }
 
+WindowManagerAndHostConst ConnectionManager::GetWindowManagerAndHost(
+    const ServerWindow* window) const {
+  const ServerWindow* last = window;
+  while (window && window->parent()) {
+    last = window;
+    window = window->parent();
+  }
+  for (WindowTreeHostImpl* host : hosts_) {
+    if (window == host->root_window()) {
+      WindowManagerAndHostConst result;
+      result.window_tree_host = host;
+      result.window_manager_state = host->GetWindowManagerStateWithRoot(last);
+      return result;
+    }
+  }
+  return WindowManagerAndHostConst();
+}
+
+WindowManagerAndHost ConnectionManager::GetWindowManagerAndHost(
+    const ServerWindow* window) {
+  WindowManagerAndHostConst result_const =
+      const_cast<const ConnectionManager*>(this)->GetWindowManagerAndHost(
+          window);
+  WindowManagerAndHost result;
+  result.window_tree_host =
+      const_cast<WindowTreeHostImpl*>(result_const.window_tree_host);
+  result.window_manager_state =
+      const_cast<WindowManagerState*>(result_const.window_manager_state);
+  return result;
+}
+
 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 (WindowTreeHostImpl* host : hosts_) {
     if (window == host->root_window())
       return host;
   }
   return nullptr;
 }
 
 WindowTreeHostImpl* ConnectionManager::GetActiveWindowTreeHost() {
   // 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(
+    uint32_t user_id,
     mojo::InterfaceRequest<mojom::WindowManagerFactoryService> request) {
-  if (window_manager_factory_service_)
+  window_manager_factory_registry_.Register(user_id, std::move(request));
+}
+
+void ConnectionManager::OnWindowManagerFactorySet() {
+  if (!hosts_.empty() || !pending_hosts_.empty())
     return;
 
-  window_manager_factory_service_.reset(
-      new WindowManagerFactoryService(std::move(request)));
+  // We've been supplied a WindowManagerFactory and no windowtreehosts have been
+  // created yet. Treat this as a signal to create a WindowTreeHost.
+  // TODO(sky): we need a better way to determine this, most likely a switch.
+  delegate_->CreateDefaultWindowTreeHosts();
 }
 
 uint32_t ConnectionManager::GenerateWindowManagerChangeId(
     WindowTreeImpl* source,
     uint32_t client_change_id) {
   const uint32_t wm_change_id = next_wm_change_id_++;
   in_flight_wm_change_map_[wm_change_id] = {source->id(), client_change_id};
   return wm_change_id;
 }
 
@@ skipping 31 matching lines @@
       !window || window->id().connection_id != wm_connection->id() ||
       !window->children().empty() || GetConnectionWithRoot(window)) {
     WindowManagerSentBogusMessage();
     return;
   }
 
   connection->OnWindowManagerCreatedTopLevelWindow(
       window_manager_change_id, change.client_change_id, window);
 }
 
+mojom::DisplayPtr ConnectionManager::DisplayForHost(WindowTreeHostImpl* host) {
+  size_t i = 0;
+  int next_x = 0;
+  for (WindowTreeHostImpl* host2 : hosts_) {
+    const ServerWindow* root = host->root_window();
+    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();
+      display->device_pixel_ratio =
+          host->GetViewportMetrics().device_pixel_ratio;
+      display->rotation = host->GetRotation();
+      // TODO(sky): make this real.
+      display->is_primary = i == 0;
+      // TODO(sky): make this real.
+      display->touch_support = mojom::TouchSupport::UNKNOWN;
+      display->frame_decoration_values =
+          host->frame_decoration_values().Clone();
+      return display;
+    }
+    next_x += root->bounds().size().width();
+    ++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));
   }
 }
 
@@ skipping 152 matching lines @@
     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 (WindowTreeHostImpl* host2 : hosts_) {
-    const ServerWindow* root = host->root_window();
-    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();
-      display->device_pixel_ratio =
-          host->GetViewportMetrics().device_pixel_ratio;
-      display->rotation = host->GetRotation();
-      // TODO(sky): make this real.
-      display->is_primary = i == 0;
-      // TODO(sky): make this real.
-      display->touch_support = mojom::TouchSupport::UNKNOWN;
-      display->frame_decoration_values =
-          host->frame_decoration_values().Clone();
-      return display;
-    }
-    next_x += root->bounds().size().width();
-    ++i;
-  }
-  NOTREACHED();
-  return mojom::Display::New();
-}
-
 mus::SurfacesState* ConnectionManager::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
 void ConnectionManager::OnScheduleWindowPaint(const ServerWindow* window) {
   if (!in_destructor_)
     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 (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;
-  if (ancestor->id().connection_id == kInvalidConnectionId)
-    window_tree = GetWindowTreeHostByWindow(ancestor)->GetWindowTree();
-  else
+  if (ancestor->id().connection_id == kInvalidConnectionId) {
+    WindowManagerAndHost wm_and_host = GetWindowManagerAndHost(ancestor);
+    window_tree = wm_and_host.window_manager_state
+                      ? wm_and_host.window_manager_state->tree()
+                      : nullptr;
+  } else {
     window_tree = GetConnection(ancestor->id().connection_id);
+  }
   if (!window_tree)
     return nullptr;
   if (surface_type == mojom::SurfaceType::DEFAULT) {
     // At embed points the default surface comes from the embedded app.
     WindowTreeImpl* connection_with_root = GetConnectionWithRoot(ancestor);
     if (connection_with_root)
       window_tree = connection_with_root;
   }
   return window_tree->GetWindowByClientId(client_window_id);
 }
@@ skipping 123 matching lines @@
   // 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));
   }
 }
 
 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