Refators display related functionality into own class

BUG=590955
TEST=covered by tests
R=ben@chromium.org

Review URL: https://codereview.chromium.org/1766943002

Cr-Commit-Position: refs/heads/master@{#379567}

20 files changed, 405 insertions, 249 deletions

diff --git a/components/mus/mus_app.cc b/components/mus/mus_app.cc
index f9ec70a..dac90c8 100644
--- a/components/mus/mus_app.cc
+++ b/components/mus/mus_app.cc
@@ -15,6 +15,7 @@
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_binding.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "components/mus/ws/window_tree_factory.h"
@@ -157,7 +158,7 @@ void MandolineUIServicesApp::OnFirstDisplayReady() {
   }
 }
 
-void MandolineUIServicesApp::OnNoMoreRootConnections() {
+void MandolineUIServicesApp::OnNoMoreDisplays() {
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
@@ -180,7 +181,7 @@ void MandolineUIServicesApp::CreateDefaultDisplays() {
 
 void MandolineUIServicesApp::Create(mojo::Connection* connection,
                                     mojom::DisplayManagerRequest request) {
-  if (!connection_manager_->has_displays()) {
+  if (!connection_manager_->display_manager()->has_displays()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->dm_request.reset(
         new mojo::InterfaceRequest<mojom::DisplayManager>(std::move(request)));
@@ -199,7 +200,7 @@ void MandolineUIServicesApp::Create(
 
 void MandolineUIServicesApp::Create(Connection* connection,
                                     mojom::WindowTreeFactoryRequest request) {
-  if (!connection_manager_->has_displays()) {
+  if (!connection_manager_->display_manager()->has_displays()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->wtf_request.reset(
         new mojo::InterfaceRequest<mojom::WindowTreeFactory>(
diff --git a/components/mus/mus_app.h b/components/mus/mus_app.h
index f471723..b94ea53 100644
--- a/components/mus/mus_app.h
+++ b/components/mus/mus_app.h
@@ -69,7 +69,7 @@ class MandolineUIServicesApp
 
   // ConnectionManagerDelegate:
   void OnFirstDisplayReady() override;
-  void OnNoMoreRootConnections() override;
+  void OnNoMoreDisplays() override;
   scoped_ptr<ws::WindowTreeBinding> CreateWindowTreeBindingForEmbedAtWindow(
       ws::ConnectionManager* connection_manager,
       ws::WindowTree* tree,
diff --git a/components/mus/ws/BUILD.gn b/components/mus/ws/BUILD.gn
index 4c6eadb..36d4aa9 100644
--- a/components/mus/ws/BUILD.gn
+++ b/components/mus/ws/BUILD.gn
@@ -21,6 +21,9 @@ source_set("lib") {
     "display.h",
     "display_binding.cc",
     "display_binding.h",
+    "display_manager.cc",
+    "display_manager.h",
+    "display_manager_delegate.h",
     "event_dispatcher.cc",
     "event_dispatcher.h",
     "event_dispatcher_delegate.h",
diff --git a/components/mus/ws/connection_manager.cc b/components/mus/ws/connection_manager.cc
index 0bd3a35..25be965 100644
--- a/components/mus/ws/connection_manager.cc
+++ b/components/mus/ws/connection_manager.cc
@@ -7,7 +7,9 @@
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/connection_manager_delegate.h"
+#include "components/mus/ws/display.h"
 #include "components/mus/ws/display_binding.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
@@ -30,7 +32,7 @@ ConnectionManager::ConnectionManager(
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_connection_id_(1),
-      next_root_id_(0),
+      display_manager_(new ws::DisplayManager(this)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
@@ -40,38 +42,15 @@ ConnectionManager::ConnectionManager(
 ConnectionManager::~ConnectionManager() {
   in_destructor_ = true;
 
-  while (!pending_displays_.empty())
-    DestroyDisplay(*pending_displays_.begin());
-  DCHECK(pending_displays_.empty());
+  // Destroys the window trees results in querying for the display. Tear down
+  // the displays first so that the trees are notified of the display going
+  // away while the display is still valid.
+  display_manager_->DestroyAllDisplays();
 
-  // DestroyDisplay() removes from |displays_| and deletes the Display.
-  while (!displays_.empty())
-    DestroyDisplay(*displays_.begin());
-  DCHECK(displays_.empty());
+  while (!tree_map_.empty())
+    DestroyTree(tree_map_.begin()->second.get());
 
-  tree_map_.clear();
-}
-
-void ConnectionManager::AddDisplay(Display* display) {
-  DCHECK_EQ(0u, pending_displays_.count(display));
-  pending_displays_.insert(display);
-}
-
-void ConnectionManager::DestroyDisplay(Display* display) {
-  for (auto& pair : tree_map_)
-    pair.second->OnWillDestroyDisplay(display);
-
-  if (pending_displays_.count(display)) {
-    pending_displays_.erase(display);
-  } else {
-    DCHECK(displays_.count(display));
-    displays_.erase(display);
-  }
-  delete display;
-
-  // If we have no more roots left, let the app know so it can terminate.
-  if (!displays_.size() && !pending_displays_.size())
-    delegate_->OnNoMoreRootConnections();
+  display_manager_.reset();
 }
 
 ServerWindow* ConnectionManager::CreateServerWindow(
@@ -88,13 +67,6 @@ ConnectionSpecificId ConnectionManager::GetAndAdvanceNextConnectionId() {
   return id;
 }
 
-uint16_t ConnectionManager::GetAndAdvanceNextRootId() {
-  // TODO(sky): handle wrapping!
-  const uint16_t id = next_root_id_++;
-  DCHECK_LT(id, next_root_id_);
-  return id;
-}
-
 WindowTree* ConnectionManager::EmbedAtWindow(
     ServerWindow* root,
     uint32_t policy_bitmask,
@@ -158,9 +130,13 @@ void ConnectionManager::DestroyTree(WindowTree* tree) {
   // Notify the hosts, taking care to only notify each host once.
   std::set<Display*> displays_notified;
   for (auto* root : tree->roots()) {
-    Display* display = GetDisplayContaining(root);
+    // WindowTree holds its roots as a const, which is right as WindowTree
+    // doesn't need to modify the window. OTOH we do. We could look up the
+    // window using the id to get non-const version, but instead we cast.
+    Display* display =
+        display_manager_->GetDisplayContaining(const_cast<ServerWindow*>(root));
     if (display && displays_notified.count(display) == 0) {
-      display->OnWindowTreeConnectionError(tree);
+      display->OnWillDestroyTree(tree);
       displays_notified.insert(display);
     }
   }
@@ -185,7 +161,7 @@ WindowTree* ConnectionManager::GetTreeWithId(
 ServerWindow* ConnectionManager::GetWindow(const WindowId& id) {
   // kInvalidConnectionId is used for Display and WindowManager nodes.
   if (id.connection_id == kInvalidConnectionId) {
-    for (Display* display : displays_) {
+    for (Display* display : display_manager_->displays()) {
       ServerWindow* window = display->GetRootWithId(id);
       if (window)
         return window;
@@ -195,22 +171,11 @@ ServerWindow* ConnectionManager::GetWindow(const WindowId& id) {
   return tree ? tree->GetWindow(id) : nullptr;
 }
 
-void ConnectionManager::SchedulePaint(const ServerWindow* window,
+void ConnectionManager::SchedulePaint(ServerWindow* window,
                                       const gfx::Rect& bounds) {
-  for (Display* display : displays_) {
-    if (display->SchedulePaintIfInViewport(window, bounds))
-      return;
-  }
-}
-
-void ConnectionManager::OnDisplayAcceleratedWidgetAvailable(Display* display) {
-  DCHECK_NE(0u, pending_displays_.count(display));
-  DCHECK_EQ(0u, displays_.count(display));
-  const bool is_first_display = displays_.empty();
-  displays_.insert(display);
-  pending_displays_.erase(display);
-  if (is_first_display)
-    delegate_->OnFirstDisplayReady();
+  Display* display = display_manager_->GetDisplayContaining(window);
+  if (display)
+    display->SchedulePaint(window, bounds);
 }
 
 void ConnectionManager::OnTreeMessagedClient(ConnectionSpecificId id) {
@@ -224,12 +189,14 @@ bool ConnectionManager::DidTreeMessageClient(ConnectionSpecificId id) const {
 
 mojom::ViewportMetricsPtr ConnectionManager::GetViewportMetricsForWindow(
     const ServerWindow* window) {
-  Display* display = GetDisplayContaining(window);
+  const Display* display = display_manager_->GetDisplayContaining(window);
   if (display)
     return display->GetViewportMetrics().Clone();
 
-  if (!displays_.empty())
-    return (*displays_.begin())->GetViewportMetrics().Clone();
+  if (!display_manager_->displays().empty())
+    return (*display_manager_->displays().begin())
+        ->GetViewportMetrics()
+        .Clone();
 
   mojom::ViewportMetricsPtr metrics = mojom::ViewportMetrics::New();
   metrics->size_in_pixels = mojo::Size::New();
@@ -247,66 +214,13 @@ const WindowTree* ConnectionManager::GetTreeWithRoot(
   return nullptr;
 }
 
-WindowManagerAndDisplayConst ConnectionManager::GetWindowManagerAndDisplay(
-    const ServerWindow* window) const {
-  const ServerWindow* last = window;
-  while (window && window->parent()) {
-    last = window;
-    window = window->parent();
-  }
-  for (Display* display : displays_) {
-    if (window == display->root_window()) {
-      WindowManagerAndDisplayConst result;
-      result.display = display;
-      result.window_manager_state =
-          display->GetWindowManagerStateWithRoot(last);
-      return result;
-    }
-  }
-  return WindowManagerAndDisplayConst();
-}
-
-WindowManagerAndDisplay ConnectionManager::GetWindowManagerAndDisplay(
-    const ServerWindow* window) {
-  WindowManagerAndDisplayConst result_const =
-      const_cast<const ConnectionManager*>(this)->GetWindowManagerAndDisplay(
-          window);
-  WindowManagerAndDisplay result;
-  result.display = const_cast<Display*>(result_const.display);
-  result.window_manager_state =
-      const_cast<WindowManagerState*>(result_const.window_manager_state);
-  return result;
-}
-
-Display* ConnectionManager::GetDisplayContaining(const ServerWindow* window) {
-  return const_cast<Display*>(
-      static_cast<const ConnectionManager*>(this)->GetDisplayContaining(
-          window));
-}
-
-const Display* ConnectionManager::GetDisplayContaining(
-    const ServerWindow* window) const {
-  while (window && window->parent())
-    window = window->parent();
-  for (Display* display : displays_) {
-    if (window == display->root_window())
-      return display;
-  }
-  return nullptr;
-}
-
-Display* ConnectionManager::GetActiveDisplay() {
-  // TODO(sky): this isn't active, but first. Make it active.
-  return displays_.size() ? *displays_.begin() : nullptr;
-}
-
 void ConnectionManager::AddDisplayManagerBinding(
     mojo::InterfaceRequest<mojom::DisplayManager> request) {
   display_manager_bindings_.AddBinding(this, std::move(request));
 }
 
 void ConnectionManager::OnFirstWindowManagerFactorySet() {
-  if (!displays_.empty() || !pending_displays_.empty())
+  if (display_manager_->has_active_or_pending_displays())
     return;
 
   // We've been supplied a WindowManagerFactory and no displays have been
@@ -367,7 +281,7 @@ void ConnectionManager::WindowManagerCreatedTopLevelWindow(
 mojom::DisplayPtr ConnectionManager::DisplayToMojomDisplay(Display* display) {
   size_t i = 0;
   int next_x = 0;
-  for (Display* display2 : displays_) {
+  for (Display* display2 : display_manager_->displays()) {
     const ServerWindow* root = display->root_window();
     if (display == display2) {
       mojom::DisplayPtr display_ptr = mojom::Display::New();
@@ -462,9 +376,8 @@ void ConnectionManager::ProcessWindowReorder(
 }
 
 void ConnectionManager::ProcessWindowDeleted(const ServerWindow* window) {
-  for (auto& pair : tree_map_) {
+  for (auto& pair : tree_map_)
     pair.second->ProcessWindowDeleted(window, IsOperationSource(pair.first));
-  }
 }
 
 void ConnectionManager::ProcessWillChangeWindowPredefinedCursor(
@@ -476,7 +389,7 @@ void ConnectionManager::ProcessWillChangeWindowPredefinedCursor(
   }
 
   // Pass the cursor change to the native window.
-  Display* display = GetDisplayContaining(window);
+  Display* display = display_manager_->GetDisplayContaining(window);
   if (display)
     display->OnCursorUpdated(window);
 }
@@ -537,23 +450,24 @@ void ConnectionManager::FinishOperation() {
 
 void ConnectionManager::MaybeUpdateNativeCursor(ServerWindow* window) {
   // This can be null in unit tests.
-  Display* display = GetDisplayContaining(window);
+  Display* display = display_manager_->GetDisplayContaining(window);
   if (display)
     display->MaybeChangeCursorOnWindowTreeChange();
 }
 
 void ConnectionManager::CallOnDisplays(
     mojom::DisplayManagerObserver* observer) {
-  mojo::Array<mojom::DisplayPtr> displays(displays_.size());
+  std::set<Display*> displays = display_manager_->displays();
+  mojo::Array<mojom::DisplayPtr> display_ptrs(displays.size());
   {
     size_t i = 0;
     // TODO(sky): need ordering!
-    for (Display* display : displays_) {
-      displays[i] = DisplayToMojomDisplay(display);
+    for (Display* display : displays) {
+      display_ptrs[i] = DisplayToMojomDisplay(display);
       ++i;
     }
   }
-  observer->OnDisplays(std::move(displays));
+  observer->OnDisplays(std::move(display_ptrs));
 }
 
 void ConnectionManager::CallOnDisplayChanged(
@@ -571,24 +485,21 @@ mus::SurfacesState* ConnectionManager::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
-void ConnectionManager::OnScheduleWindowPaint(const ServerWindow* window) {
+void ConnectionManager::OnScheduleWindowPaint(ServerWindow* window) {
   if (!in_destructor_)
     SchedulePaint(window, gfx::Rect(window->bounds().size()));
 }
 
 const ServerWindow* ConnectionManager::GetRootWindow(
     const ServerWindow* window) const {
-  const Display* display = GetDisplayContaining(window);
+  const Display* display = display_manager_->GetDisplayContaining(window);
   return display ? display->root_window() : nullptr;
 }
 
 void ConnectionManager::ScheduleSurfaceDestruction(ServerWindow* window) {
-  for (Display* display : displays_) {
-    if (display->root_window()->Contains(window)) {
-      display->ScheduleSurfaceDestruction(window);
-      break;
-    }
-  }
+  Display* display = display_manager_->GetDisplayContaining(window);
+  if (display)
+    display->ScheduleSurfaceDestruction(window);
 }
 
 ServerWindow* ConnectionManager::FindWindowForSurface(
@@ -598,7 +509,7 @@ ServerWindow* ConnectionManager::FindWindowForSurface(
   WindowTree* window_tree;
   if (ancestor->id().connection_id == kInvalidConnectionId) {
     WindowManagerAndDisplay wm_and_display =
-        GetWindowManagerAndDisplay(ancestor);
+        display_manager_->GetWindowManagerAndDisplay(ancestor);
     window_tree = wm_and_display.window_manager_state
                       ? wm_and_display.window_manager_state->tree()
                       : nullptr;
@@ -617,8 +528,7 @@ ServerWindow* ConnectionManager::FindWindowForSurface(
 }
 
 void ConnectionManager::OnWindowDestroyed(ServerWindow* window) {
-  if (!in_destructor_)
-    ProcessWindowDeleted(window);
+  ProcessWindowDeleted(window);
 }
 
 void ConnectionManager::OnWillChangeWindowHierarchy(ServerWindow* window,
@@ -723,7 +633,7 @@ void ConnectionManager::OnWindowSharedPropertyChanged(
 void ConnectionManager::OnWindowTextInputStateChanged(
     ServerWindow* window,
     const ui::TextInputState& state) {
-  Display* display = GetDisplayContaining(window);
+  Display* display = display_manager_->GetDisplayContaining(window);
   display->UpdateTextInputState(window, state);
 }
 
@@ -761,5 +671,18 @@ void ConnectionManager::AddObserver(mojom::DisplayManagerObserverPtr observer) {
   display_manager_observers_.AddInterfacePtr(std::move(observer));
 }
 
+void ConnectionManager::OnWillDestroyDisplay(Display* display) {
+  for (auto& pair : tree_map_)
+    pair.second->OnWillDestroyDisplay(display);
+}
+
+void ConnectionManager::OnFirstDisplayReady() {
+  delegate_->OnFirstDisplayReady();
+}
+
+void ConnectionManager::OnNoMoreDisplays() {
+  delegate_->OnNoMoreDisplays();
+}
+
 }  // namespace ws
 }  // namespace mus
diff --git a/components/mus/ws/connection_manager.h b/components/mus/ws/connection_manager.h
index b341bcd..92d63ef 100644
--- a/components/mus/ws/connection_manager.h
+++ b/components/mus/ws/connection_manager.h
@@ -20,6 +20,7 @@
 #include "components/mus/public/interfaces/window_tree_host.mojom.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/display.h"
+#include "components/mus/ws/display_manager_delegate.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window_delegate.h"
@@ -36,25 +37,12 @@ namespace mus {
 namespace ws {
 
 class ConnectionManagerDelegate;
+class DisplayManager;
 class ServerWindow;
 class WindowManagerState;
 class WindowTree;
 class WindowTreeBinding;
 
-struct WindowManagerAndDisplay {
-  WindowManagerAndDisplay() : window_manager_state(nullptr), display(nullptr) {}
-
-  WindowManagerState* window_manager_state;
-  Display* display;
-};
-
-struct WindowManagerAndDisplayConst {
-  WindowManagerAndDisplayConst()
-      : window_manager_state(nullptr), display(nullptr) {}
-  const WindowManagerState* window_manager_state;
-  const Display* display;
-};
-
 // ConnectionManager manages the set of connections to the window server (all
 // the WindowTrees) as well as providing the root of the hierarchy.
 //
@@ -62,7 +50,8 @@ struct WindowManagerAndDisplayConst {
 // clearer.
 class ConnectionManager : public ServerWindowDelegate,
                           public ServerWindowObserver,
-                          public mojom::DisplayManager {
+                          public mojom::DisplayManager,
+                          public DisplayManagerDelegate {
  public:
   ConnectionManager(ConnectionManagerDelegate* delegate,
                     const scoped_refptr<mus::SurfacesState>& surfaces_state);
@@ -72,10 +61,10 @@ class ConnectionManager : public ServerWindowDelegate,
 
   UserIdTracker* user_id_tracker() { return &user_id_tracker_; }
 
-  // Adds/removes a Display. ConnectionManager owns the Displays.
-  void AddDisplay(Display* display);
-  void DestroyDisplay(Display* display);
-  std::set<Display*> displays() { return displays_; }
+  ws::DisplayManager* display_manager() { return display_manager_.get(); }
+  const ws::DisplayManager* display_manager() const {
+    return display_manager_.get();
+  }
 
   // Creates a new ServerWindow. The return value is owned by the caller, but
   // must be destroyed before ConnectionManager.
@@ -86,10 +75,6 @@ class ConnectionManager : public ServerWindowDelegate,
   // Returns the id for the next WindowTree.
   ConnectionSpecificId GetAndAdvanceNextConnectionId();
 
-  // Returns the id for the next root window (both for the root of a Display
-  // as well as the root of WindowManagers).
-  uint16_t GetAndAdvanceNextRootId();
-
   // See description of WindowTree::Embed() for details. This assumes
   // |transport_window_id| is valid.
   WindowTree* EmbedAtWindow(ServerWindow* root,
@@ -116,19 +101,13 @@ class ConnectionManager : public ServerWindowDelegate,
   ServerWindow* GetWindow(const WindowId& id);
 
   // Schedules a paint for the specified region in the coordinates of |window|.
-  void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
+  void SchedulePaint(ServerWindow* window, const gfx::Rect& bounds);
 
   OperationType current_operation_type() const {
     return current_operation_ ? current_operation_->type()
                               : OperationType::NONE;
   }
 
-  // Invoked when the Display's PlatformDisplay is closed.
-  void OnDisplayClosed();
-
-  // Called when the AcceleratedWidget is available for |display|.
-  void OnDisplayAcceleratedWidgetAvailable(Display* display);
-
   // Invoked when a connection messages a client about the change. This is used
   // to avoid sending ServerChangeIdAdvanced() unnecessarily.
   void OnTreeMessagedClient(ConnectionSpecificId id);
@@ -148,20 +127,6 @@ class ConnectionManager : public ServerWindowDelegate,
   }
   const WindowTree* GetTreeWithRoot(const ServerWindow* window) const;
 
-  // Returns the Display that contains |window|, or null if |window| is not
-  // attached to a display.
-  Display* GetDisplayContaining(const ServerWindow* window);
-  const Display* GetDisplayContaining(const ServerWindow* window) const;
-
-  WindowManagerAndDisplayConst GetWindowManagerAndDisplay(
-      const ServerWindow* window) const;
-  WindowManagerAndDisplay GetWindowManagerAndDisplay(
-      const ServerWindow* window);
-
-  Display* GetActiveDisplay();
-
-  bool has_displays() const { return !displays_.empty(); }
-
   void AddDisplayManagerBinding(
       mojo::InterfaceRequest<mojom::DisplayManager> request);
 
@@ -270,7 +235,7 @@ class ConnectionManager : public ServerWindowDelegate,
 
   // Overridden from ServerWindowDelegate:
   mus::SurfacesState* GetSurfacesState() override;
-  void OnScheduleWindowPaint(const ServerWindow* window) override;
+  void OnScheduleWindowPaint(ServerWindow* window) override;
   const ServerWindow* GetRootWindow(const ServerWindow* window) const override;
   void ScheduleSurfaceDestruction(ServerWindow* window) override;
   ServerWindow* FindWindowForSurface(
@@ -313,6 +278,11 @@ class ConnectionManager : public ServerWindowDelegate,
   // Overriden from mojom::DisplayManager:
   void AddObserver(mojom::DisplayManagerObserverPtr observer) override;
 
+  // DisplayManagerDelegate:
+  void OnWillDestroyDisplay(Display* display) override;
+  void OnFirstDisplayReady() override;
+  void OnNoMoreDisplays() override;
+
   UserIdTracker user_id_tracker_;
 
   ConnectionManagerDelegate* delegate_;
@@ -323,18 +293,11 @@ class ConnectionManager : public ServerWindowDelegate,
   // ID to use for next WindowTree.
   ConnectionSpecificId next_connection_id_;
 
-  // ID to use for next root node.
-  uint16_t next_root_id_;
+  scoped_ptr<ws::DisplayManager> display_manager_;
 
   // Set of WindowTrees.
   WindowTreeMap tree_map_;
 
-  // Displays are initially added to |pending_displays_|. When the display is
-  // initialized it is moved to |displays_|. ConnectionManager owns the
-  // Displays.
-  std::set<Display*> pending_displays_;
-  std::set<Display*> displays_;
-
   // If non-null then we're processing a client operation. The Operation is
   // not owned by us (it's created on the stack by WindowTree).
   Operation* current_operation_;
diff --git a/components/mus/ws/connection_manager_delegate.h b/components/mus/ws/connection_manager_delegate.h
index ce4fad4..a777ecb 100644
--- a/components/mus/ws/connection_manager_delegate.h
+++ b/components/mus/ws/connection_manager_delegate.h
@@ -35,7 +35,7 @@ class ConnectionManagerDelegate {
   // Called once when the AcceleratedWidget of a Display is available.
   virtual void OnFirstDisplayReady();
 
-  virtual void OnNoMoreRootConnections() = 0;
+  virtual void OnNoMoreDisplays() = 0;
 
   // Creates a WindowTreeBinding in response to Embed() calls on the
   // ConnectionManager.
diff --git a/components/mus/ws/display.cc b/components/mus/ws/display.cc
index 3ee54d13..80fbf11 100644
--- a/components/mus/ws/display.cc
+++ b/components/mus/ws/display.cc
@@ -10,6 +10,7 @@
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/connection_manager_delegate.h"
 #include "components/mus/ws/display_binding.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/window_manager_factory_service.h"
@@ -128,7 +129,7 @@ Display::~Display() {
 void Display::Init(scoped_ptr<DisplayBinding> binding) {
   init_called_ = true;
   binding_ = std::move(binding);
-  connection_manager_->AddDisplay(this);
+  display_manager()->AddDisplay(this);
   InitWindowManagersIfNecessary();
 }
 
@@ -138,13 +139,10 @@ void Display::SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values) {
   connection_manager_->ProcessFrameDecorationValuesChanged(this);
 }
 
-bool Display::SchedulePaintIfInViewport(const ServerWindow* window,
-                                        const gfx::Rect& bounds) {
-  if (root_->Contains(window)) {
-    platform_display_->SchedulePaint(window, bounds);
-    return true;
-  }
-  return false;
+void Display::SchedulePaint(const ServerWindow* window,
+                            const gfx::Rect& bounds) {
+  DCHECK(root_->Contains(window));
+  platform_display_->SchedulePaint(window, bounds);
 }
 
 void Display::ScheduleSurfaceDestruction(ServerWindow* window) {
@@ -247,7 +245,7 @@ void Display::SetImeVisibility(ServerWindow* window, bool visible) {
   platform_display_->SetImeVisibility(visible);
 }
 
-void Display::OnWindowTreeConnectionError(WindowTree* tree) {
+void Display::OnWillDestroyTree(WindowTree* tree) {
   for (auto it = window_manager_state_map_.begin();
        it != window_manager_state_map_.end(); ++it) {
     if (it->second->tree() == tree) {
@@ -298,7 +296,7 @@ void Display::InitWindowManagersIfNecessary() {
   if (!init_called_ || !root_)
     return;
 
-  connection_manager_->OnDisplayAcceleratedWidgetAvailable(this);
+  display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   if (binding_) {
     scoped_ptr<WindowManagerState> wms_ptr(new WindowManagerState(this));
     WindowManagerState* wms = wms_ptr.get();
@@ -312,6 +310,14 @@ void Display::InitWindowManagersIfNecessary() {
   }
 }
 
+DisplayManager* Display::display_manager() {
+  return connection_manager_->display_manager();
+}
+
+const DisplayManager* Display::display_manager() const {
+  return connection_manager_->display_manager();
+}
+
 void Display::OnEventAckTimeout() {
   // TODO(sad): Figure out what we should do.
   NOTIMPLEMENTED() << "Event ACK timed out.";
@@ -435,7 +441,7 @@ void Display::OnNativeCaptureLost() {
 }
 
 void Display::OnDisplayClosed() {
-  connection_manager_->DestroyDisplay(this);
+  display_manager()->DestroyDisplay(this);
 }
 
 void Display::OnViewportMetricsChanged(
@@ -443,7 +449,7 @@ void Display::OnViewportMetricsChanged(
     const mojom::ViewportMetrics& new_metrics) {
   if (!root_) {
     root_.reset(connection_manager_->CreateServerWindow(
-        RootWindowId(connection_manager_->GetAndAdvanceNextRootId()),
+        display_manager()->GetAndAdvanceNextRootId(),
         ServerWindow::Properties()));
     root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
     root_->SetVisible(true);
@@ -542,7 +548,8 @@ void Display::OnFocusChanged(FocusControllerChangeSource change_source,
   WindowTree* wms_tree_with_old_focused_window = nullptr;
   if (old_focused_window) {
     WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(old_focused_window)
+        display_manager()
+            ->GetWindowManagerAndDisplay(old_focused_window)
             .window_manager_state;
     wms_tree_with_old_focused_window = wms ? wms->tree() : nullptr;
     if (wms_tree_with_old_focused_window &&
@@ -556,7 +563,8 @@ void Display::OnFocusChanged(FocusControllerChangeSource change_source,
   }
   if (new_focused_window) {
     WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(new_focused_window)
+        display_manager()
+            ->GetWindowManagerAndDisplay(new_focused_window)
             .window_manager_state;
     WindowTree* wms_tree = wms ? wms->tree() : nullptr;
     if (wms_tree && wms_tree != wms_tree_with_old_focused_window &&
@@ -631,8 +639,8 @@ void Display::OnUserIdRemoved(const UserId& id) {
   if (!state)
     return;
 
-  // DestroyTree() calls back to OnWindowTreeConnectionError() and the
-  // WindowManagerState is destroyed (and removed).
+  // DestroyTree() calls back to OnWillDestroyTree() and the WindowManagerState
+  // is destroyed (and removed).
   connection_manager_->DestroyTree(state->tree());
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
diff --git a/components/mus/ws/display.h b/components/mus/ws/display.h
index 6cf8975..761aa82 100644
--- a/components/mus/ws/display.h
+++ b/components/mus/ws/display.h
@@ -32,6 +32,7 @@ namespace ws {
 
 class ConnectionManager;
 class DisplayBinding;
+class DisplayManager;
 class FocusController;
 class WindowManagerState;
 class WindowTree;
@@ -79,11 +80,8 @@ class Display : public PlatformDisplayDelegate,
     return *frame_decoration_values_;
   }
 
-  // Schedules a paint for the specified region in the coordinates of |window|
-  // if the |window| is in this viewport. Returns whether |window| is in the
-  // viewport.
-  bool SchedulePaintIfInViewport(const ServerWindow* window,
-                                 const gfx::Rect& bounds);
+  // Schedules a paint for the specified region in the coordinates of |window|.
+  void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
 
   // Schedules destruction of surfaces in |window|. If a frame has been
   // scheduled but not drawn surface destruction is delayed until the frame is
@@ -136,9 +134,8 @@ class Display : public PlatformDisplayDelegate,
     return event_dispatcher_.capture_window();
   }
 
-  // Called just before |tree| is destroyed after its connection encounters an
-  // error.
-  void OnWindowTreeConnectionError(WindowTree* tree);
+  // Called just before |tree| is destroyed.
+  void OnWillDestroyTree(WindowTree* tree);
 
   // Called when a client updates a cursor. This will update the cursor on the
   // native display if the cursor is currently under |window|.
@@ -181,6 +178,9 @@ class Display : public PlatformDisplayDelegate,
   // Inits the necessary state once the display is ready.
   void InitWindowManagersIfNecessary();
 
+  DisplayManager* display_manager();
+  const DisplayManager* display_manager() const;
+
   void OnEventAckTimeout();
 
   // Schedules an event to be processed later.
diff --git a/components/mus/ws/display_manager.cc b/components/mus/ws/display_manager.cc
new file mode 100644
index 0000000..8fda170
--- /dev/null
+++ b/components/mus/ws/display_manager.cc
@@ -0,0 +1,128 @@
+// Copyright 2016 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/display_manager.h"
+
+#include "components/mus/ws/display.h"
+#include "components/mus/ws/display_manager_delegate.h"
+#include "components/mus/ws/server_window.h"
+
+namespace mus {
+namespace ws {
+
+DisplayManager::DisplayManager(DisplayManagerDelegate* delegate)
+    : delegate_(delegate), next_root_id_(0) {}
+
+DisplayManager::~DisplayManager() {
+  DestroyAllDisplays();
+}
+
+void DisplayManager::AddDisplay(Display* display) {
+  DCHECK_EQ(0u, pending_displays_.count(display));
+  pending_displays_.insert(display);
+}
+
+void DisplayManager::DestroyDisplay(Display* display) {
+  delegate_->OnWillDestroyDisplay(display);
+
+  if (pending_displays_.count(display)) {
+    pending_displays_.erase(display);
+  } else {
+    DCHECK(displays_.count(display));
+    displays_.erase(display);
+  }
+  delete display;
+
+  // If we have no more roots left, let the app know so it can terminate.
+  // TODO(sky): move to delegate/observer.
+  if (!displays_.size() && !pending_displays_.size())
+    delegate_->OnNoMoreDisplays();
+}
+
+void DisplayManager::DestroyAllDisplays() {
+  while (!pending_displays_.empty())
+    DestroyDisplay(*pending_displays_.begin());
+  DCHECK(pending_displays_.empty());
+
+  while (!displays_.empty())
+    DestroyDisplay(*displays_.begin());
+  DCHECK(displays_.empty());
+}
+
+std::set<const Display*> DisplayManager::displays() const {
+  std::set<const Display*> ret_value(displays_.begin(), displays_.end());
+  return ret_value;
+}
+
+Display* DisplayManager::GetDisplayContaining(ServerWindow* window) {
+  return const_cast<Display*>(
+      static_cast<const DisplayManager*>(this)->GetDisplayContaining(window));
+}
+
+const Display* DisplayManager::GetDisplayContaining(
+    const ServerWindow* window) const {
+  while (window && window->parent())
+    window = window->parent();
+  for (Display* display : displays_) {
+    if (window == display->root_window())
+      return display;
+  }
+  return nullptr;
+}
+
+Display* DisplayManager::GetActiveDisplay() {
+  // TODO(sky): this isn't active, but first. Make it active.
+  return displays_.size() ? *displays_.begin() : nullptr;
+}
+
+WindowManagerAndDisplayConst DisplayManager::GetWindowManagerAndDisplay(
+    const ServerWindow* window) const {
+  const ServerWindow* last = window;
+  while (window && window->parent()) {
+    last = window;
+    window = window->parent();
+  }
+  for (Display* display : displays_) {
+    if (window == display->root_window()) {
+      WindowManagerAndDisplayConst result;
+      result.display = display;
+      result.window_manager_state =
+          display->GetWindowManagerStateWithRoot(last);
+      return result;
+    }
+  }
+  return WindowManagerAndDisplayConst();
+}
+
+WindowManagerAndDisplay DisplayManager::GetWindowManagerAndDisplay(
+    const ServerWindow* window) {
+  WindowManagerAndDisplayConst result_const =
+      const_cast<const DisplayManager*>(this)->GetWindowManagerAndDisplay(
+          window);
+  WindowManagerAndDisplay result;
+  result.display = const_cast<Display*>(result_const.display);
+  result.window_manager_state =
+      const_cast<WindowManagerState*>(result_const.window_manager_state);
+  return result;
+}
+
+WindowId DisplayManager::GetAndAdvanceNextRootId() {
+  // TODO(sky): handle wrapping!
+  const uint16_t id = next_root_id_++;
+  DCHECK_LT(id, next_root_id_);
+  return RootWindowId(id);
+}
+
+void DisplayManager::OnDisplayAcceleratedWidgetAvailable(Display* display) {
+  DCHECK_NE(0u, pending_displays_.count(display));
+  DCHECK_EQ(0u, displays_.count(display));
+  const bool is_first_display = displays_.empty();
+  displays_.insert(display);
+  pending_displays_.erase(display);
+  if (is_first_display)
+    delegate_->OnFirstDisplayReady();
+}
+
+}  // namespace ws
+}  // namespace mus
diff --git a/components/mus/ws/display_manager.h b/components/mus/ws/display_manager.h
new file mode 100644
index 0000000..7123469
--- /dev/null
+++ b/components/mus/ws/display_manager.h
@@ -0,0 +1,90 @@
+// Copyright 2016 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_DISPLAY_MANAGER_H_
+#define COMPONENTS_MUS_WS_DISPLAY_MANAGER_H_
+
+#include <set>
+
+#include "base/macros.h"
+#include "components/mus/ws/ids.h"
+
+namespace mus {
+namespace ws {
+
+class Display;
+class DisplayManagerDelegate;
+class ServerWindow;
+class WindowManagerState;
+
+struct WindowManagerAndDisplay {
+  WindowManagerAndDisplay() : window_manager_state(nullptr), display(nullptr) {}
+
+  WindowManagerState* window_manager_state;
+  Display* display;
+};
+
+struct WindowManagerAndDisplayConst {
+  WindowManagerAndDisplayConst()
+      : window_manager_state(nullptr), display(nullptr) {}
+  const WindowManagerState* window_manager_state;
+  const Display* display;
+};
+
+class DisplayManager {
+ public:
+  explicit DisplayManager(DisplayManagerDelegate* delegate);
+  ~DisplayManager();
+
+  // Adds/removes a Display. DisplayManager owns the Displays.
+  // TODO(sky): make add take a scoped_ptr.
+  void AddDisplay(Display* display);
+  void DestroyDisplay(Display* display);
+  void DestroyAllDisplays();
+  const std::set<Display*>& displays() { return displays_; }
+  std::set<const Display*> displays() const;
+
+  // Returns the Display that contains |window|, or null if |window| is not
+  // attached to a display.
+  Display* GetDisplayContaining(ServerWindow* window);
+  const Display* GetDisplayContaining(const ServerWindow* window) const;
+
+  Display* GetActiveDisplay();
+
+  WindowManagerAndDisplayConst GetWindowManagerAndDisplay(
+      const ServerWindow* window) const;
+  WindowManagerAndDisplay GetWindowManagerAndDisplay(
+      const ServerWindow* window);
+
+  bool has_displays() const { return !displays_.empty(); }
+  bool has_active_or_pending_displays() const {
+    return !displays_.empty() || !pending_displays_.empty();
+  }
+
+  // Returns the id for the next root window (both for the root of a Display
+  // as well as the root of WindowManagers).
+  WindowId GetAndAdvanceNextRootId();
+
+  // Called when the AcceleratedWidget is available for |display|.
+  void OnDisplayAcceleratedWidgetAvailable(Display* display);
+
+ private:
+  DisplayManagerDelegate* delegate_;
+
+  // Displays are initially added to |pending_displays_|. When the display is
+  // initialized it is moved to |displays_|. ConnectionManager owns the
+  // Displays.
+  std::set<Display*> pending_displays_;
+  std::set<Display*> displays_;
+
+  // ID to use for next root node.
+  ConnectionSpecificId next_root_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(DisplayManager);
+};
+
+}  // namespace ws
+}  // namespace mus
+
+#endif  // COMPONENTS_MUS_WS_DISPLAY_MANAGER_H_
diff --git a/components/mus/ws/display_manager_delegate.h b/components/mus/ws/display_manager_delegate.h
new file mode 100644
index 0000000..0af7760
--- /dev/null
+++ b/components/mus/ws/display_manager_delegate.h
@@ -0,0 +1,26 @@
+// Copyright 2016 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_DISPLAY_MANAGER_DELEGATE_H_
+#define COMPONENTS_MUS_WS_DISPLAY_MANAGER_DELEGATE_H_
+
+namespace mus {
+namespace ws {
+
+class Display;
+
+class DisplayManagerDelegate {
+ public:
+  virtual void OnWillDestroyDisplay(Display* display) = 0;
+  virtual void OnFirstDisplayReady() = 0;
+  virtual void OnNoMoreDisplays() = 0;
+
+ protected:
+  virtual ~DisplayManagerDelegate() {}
+};
+
+}  // namespace ws
+}  // namespace mus
+
+#endif  // COMPONENTS_MUS_WS_DISPLAY_MANAGER_DELEGATE_H_
diff --git a/components/mus/ws/display_unittest.cc b/components/mus/ws/display_unittest.cc
index 663e04c..128d3a97 100644
--- a/components/mus/ws/display_unittest.cc
+++ b/components/mus/ws/display_unittest.cc
@@ -14,6 +14,7 @@
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/connection_manager_delegate.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/ids.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/platform_display_factory.h"
@@ -80,16 +81,17 @@ TEST_F(DisplayTest, CallsCreateDefaultDisplays) {
 
   const UserId kTestId1 = "2";
   const UserId kTestId2 = "21";
+  DisplayManager* display_manager = connection_manager_->display_manager();
   WindowManagerFactoryRegistryTestApi(
       connection_manager_->window_manager_factory_registry())
       .AddService(kTestId1, &test_window_manager_factory_);
   // The first register should trigger creation of the default
   // Displays. There should be kNumHostsToCreate Displays.
   EXPECT_EQ(static_cast<size_t>(kNumHostsToCreate),
-            connection_manager_->displays().size());
+            display_manager->displays().size());
 
   // Each host should have a WindowManagerState for kTestId1.
-  for (Display* display : connection_manager_->displays()) {
+  for (Display* display : display_manager->displays()) {
     EXPECT_EQ(1u, display->num_window_manger_states());
     EXPECT_TRUE(display->GetWindowManagerStateForUser(kTestId1));
     EXPECT_FALSE(display->GetWindowManagerStateForUser(kTestId2));
@@ -99,7 +101,7 @@ TEST_F(DisplayTest, CallsCreateDefaultDisplays) {
   WindowManagerFactoryRegistryTestApi(
       connection_manager_->window_manager_factory_registry())
       .AddService(kTestId2, &test_window_manager_factory_);
-  for (Display* display : connection_manager_->displays()) {
+  for (Display* display : display_manager->displays()) {
     ASSERT_EQ(2u, display->num_window_manger_states());
     WindowManagerState* state1 =
         display->GetWindowManagerStateForUser(kTestId1);
@@ -123,11 +125,12 @@ TEST_F(DisplayTest, Destruction) {
       .AddService(kTestId1, &test_window_manager_factory_);
 
   // Add another registry, should trigger creation of another wm.
+  DisplayManager* display_manager = connection_manager_->display_manager();
   WindowManagerFactoryRegistryTestApi(
       connection_manager_->window_manager_factory_registry())
       .AddService(kTestId2, &test_window_manager_factory_);
-  ASSERT_EQ(1u, connection_manager_->displays().size());
-  Display* display = *connection_manager_->displays().begin();
+  ASSERT_EQ(1u, display_manager->displays().size());
+  Display* display = *display_manager->displays().begin();
   ASSERT_EQ(2u, display->num_window_manger_states());
   // There should be two trees, one for each windowmanager.
   EXPECT_EQ(2u, connection_manager_->num_trees());
@@ -139,15 +142,15 @@ TEST_F(DisplayTest, Destruction) {
     connection_manager_->DestroyTree(state->tree());
     ASSERT_EQ(1u, display->num_window_manger_states());
     EXPECT_FALSE(display->GetWindowManagerStateForUser(kTestId1));
-    EXPECT_EQ(1u, connection_manager_->displays().size());
+    EXPECT_EQ(1u, display_manager->displays().size());
     EXPECT_EQ(1u, connection_manager_->num_trees());
   }
 
-  EXPECT_FALSE(connection_manager_delegate_.got_on_no_more_connections());
+  EXPECT_FALSE(connection_manager_delegate_.got_on_no_more_displays());
   // Destroy the Display, which should shutdown the trees.
-  connection_manager_->DestroyDisplay(display);
+  connection_manager_->display_manager()->DestroyDisplay(display);
   EXPECT_EQ(0u, connection_manager_->num_trees());
-  EXPECT_TRUE(connection_manager_delegate_.got_on_no_more_connections());
+  EXPECT_TRUE(connection_manager_delegate_.got_on_no_more_displays());
 }
 
 }  // namespace test
diff --git a/components/mus/ws/server_window_delegate.h b/components/mus/ws/server_window_delegate.h
index 760d45a..8aaad34 100644
--- a/components/mus/ws/server_window_delegate.h
+++ b/components/mus/ws/server_window_delegate.h
@@ -23,7 +23,7 @@ class ServerWindowDelegate {
  public:
   virtual SurfacesState* GetSurfacesState() = 0;
 
-  virtual void OnScheduleWindowPaint(const ServerWindow* window) = 0;
+  virtual void OnScheduleWindowPaint(ServerWindow* window) = 0;
 
   // Returns the root of the window tree to which this |window| is attached.
   // Returns null if this window is not attached up through to a root window.
diff --git a/components/mus/ws/test_server_window_delegate.cc b/components/mus/ws/test_server_window_delegate.cc
index 24677a6..9a033b3 100644
--- a/components/mus/ws/test_server_window_delegate.cc
+++ b/components/mus/ws/test_server_window_delegate.cc
@@ -17,8 +17,7 @@ mus::SurfacesState* TestServerWindowDelegate::GetSurfacesState() {
   return nullptr;
 }
 
-void TestServerWindowDelegate::OnScheduleWindowPaint(
-    const ServerWindow* window) {}
+void TestServerWindowDelegate::OnScheduleWindowPaint(ServerWindow* window) {}
 
 const ServerWindow* TestServerWindowDelegate::GetRootWindow(
     const ServerWindow* window) const {
diff --git a/components/mus/ws/test_server_window_delegate.h b/components/mus/ws/test_server_window_delegate.h
index d299984..f7661e5 100644
--- a/components/mus/ws/test_server_window_delegate.h
+++ b/components/mus/ws/test_server_window_delegate.h
@@ -24,7 +24,7 @@ class TestServerWindowDelegate : public ServerWindowDelegate {
  private:
   // ServerWindowDelegate:
   mus::SurfacesState* GetSurfacesState() override;
-  void OnScheduleWindowPaint(const ServerWindow* window) override;
+  void OnScheduleWindowPaint(ServerWindow* window) override;
   const ServerWindow* GetRootWindow(const ServerWindow* window) const override;
   void ScheduleSurfaceDestruction(ServerWindow* window) override;
   ServerWindow* FindWindowForSurface(
diff --git a/components/mus/ws/test_utils.cc b/components/mus/ws/test_utils.cc
index 55dc179..a02b675 100644
--- a/components/mus/ws/test_utils.cc
+++ b/components/mus/ws/test_utils.cc
@@ -247,8 +247,8 @@ void TestWindowTreeBinding::SetIncomingMethodCallProcessingPaused(bool paused) {
 TestConnectionManagerDelegate::TestConnectionManagerDelegate() {}
 TestConnectionManagerDelegate::~TestConnectionManagerDelegate() {}
 
-void TestConnectionManagerDelegate::OnNoMoreRootConnections() {
-  got_on_no_more_connections_ = true;
+void TestConnectionManagerDelegate::OnNoMoreDisplays() {
+  got_on_no_more_displays_ = true;
 }
 
 scoped_ptr<WindowTreeBinding>
diff --git a/components/mus/ws/test_utils.h b/components/mus/ws/test_utils.h
index 216d3a0..7746f2b 100644
--- a/components/mus/ws/test_utils.h
+++ b/components/mus/ws/test_utils.h
@@ -211,12 +211,10 @@ class TestConnectionManagerDelegate : public ConnectionManagerDelegate {
   }
   TestWindowTreeBinding* last_binding() { return last_binding_; }
 
-  bool got_on_no_more_connections() const {
-    return got_on_no_more_connections_;
-  }
+  bool got_on_no_more_displays() const { return got_on_no_more_displays_; }
 
   // ConnectionManagerDelegate:
-  void OnNoMoreRootConnections() override;
+  void OnNoMoreDisplays() override;
   scoped_ptr<WindowTreeBinding> CreateWindowTreeBindingForEmbedAtWindow(
       ws::ConnectionManager* connection_manager,
       ws::WindowTree* tree,
@@ -231,7 +229,7 @@ class TestConnectionManagerDelegate : public ConnectionManagerDelegate {
   TestWindowTreeBinding* last_binding_ = nullptr;
   Display* display_ = nullptr;
   ConnectionManager* connection_manager_ = nullptr;
-  bool got_on_no_more_connections_ = false;
+  bool got_on_no_more_displays_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnectionManagerDelegate);
 };
diff --git a/components/mus/ws/window_manager_state.cc b/components/mus/ws/window_manager_state.cc
index f017dca..53879ec 100644
--- a/components/mus/ws/window_manager_state.cc
+++ b/components/mus/ws/window_manager_state.cc
@@ -5,6 +5,7 @@
 #include "components/mus/ws/window_manager_state.h"
 
 #include "components/mus/ws/connection_manager.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/server_window.h"
 #include "mojo/shell/public/interfaces/connector.mojom.h"
 
@@ -27,7 +28,7 @@ WindowManagerState::WindowManagerState(Display* display,
       user_id_(user_id) {
   ConnectionManager* connection_manager = display_->connection_manager();
   root_.reset(connection_manager->CreateServerWindow(
-      RootWindowId(connection_manager->GetAndAdvanceNextRootId()),
+      connection_manager->display_manager()->GetAndAdvanceNextRootId(),
       ServerWindow::Properties()));
   // Our root is always a child of the Display's root. Do this
   // before the WindowTree has been created so that the client doesn't get
diff --git a/components/mus/ws/window_tree.cc b/components/mus/ws/window_tree.cc
index 7e1c405..8d902d3 100644
--- a/components/mus/ws/window_tree.cc
+++ b/components/mus/ws/window_tree.cc
@@ -13,6 +13,7 @@
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/default_access_policy.h"
 #include "components/mus/ws/display.h"
+#include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/platform_display.h"
@@ -154,7 +155,7 @@ const ServerWindow* WindowTree::GetWindowByClientId(
 }
 
 const Display* WindowTree::GetDisplay(const ServerWindow* window) const {
-  return window ? connection_manager_->GetDisplayContaining(window) : nullptr;
+  return window ? display_manager()->GetDisplayContaining(window) : nullptr;
 }
 
 void WindowTree::OnWindowDestroyingTreeImpl(WindowTree* tree) {
@@ -563,6 +564,14 @@ void WindowTree::ProcessTransientWindowRemoved(
                                      transient_client_window_id.id);
 }
 
+DisplayManager* WindowTree::display_manager() {
+  return connection_manager_->display_manager();
+}
+
+const DisplayManager* WindowTree::display_manager() const {
+  return connection_manager_->display_manager();
+}
+
 Display* WindowTree::GetDisplayForWindowManager() {
   // The WindowTree for the wm has one and only one root.
   CHECK_EQ(1u, roots_.size());
@@ -572,7 +581,7 @@ Display* WindowTree::GetDisplayForWindowManager() {
 
   Display* display = GetDisplay(*roots_.begin());
   WindowManagerAndDisplay wm_and_display =
-      connection_manager_->GetWindowManagerAndDisplay(*roots_.begin());
+      display_manager()->GetWindowManagerAndDisplay(*roots_.begin());
   CHECK(wm_and_display.display);
   CHECK(wm_and_display.window_manager_state);
   DCHECK_EQ(this, wm_and_display.window_manager_state->tree());
@@ -592,9 +601,9 @@ bool WindowTree::ShouldRouteToWindowManager(const ServerWindow* window) const {
 
   // The WindowManager is attached to the root of the Display, if there isn't a
   // WindowManager attached no need to route to it.
-  const WindowManagerState* wms =
-      connection_manager_->GetWindowManagerAndDisplay(window)
-          .window_manager_state;
+  const WindowManagerState* wms = display_manager()
+                                      ->GetWindowManagerAndDisplay(window)
+                                      .window_manager_state;
   if (!wms || !wms->tree()->window_manager_internal_)
     return false;
 
@@ -891,7 +900,7 @@ void WindowTree::NewTopLevelWindow(
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   DCHECK(!waiting_for_top_level_window_info_);
   const ClientWindowId client_window_id(transport_window_id);
-  Display* display = connection_manager_->GetActiveDisplay();
+  Display* display = display_manager()->GetActiveDisplay();
   // TODO(sky): need a way for client to provide context.
   WindowManagerState* wms =
       display ? display->GetFirstWindowManagerState() : nullptr;
@@ -1039,9 +1048,9 @@ void WindowTree::SetWindowBounds(uint32_t change_id,
         connection_manager_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
-    WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(window)
-            .window_manager_state;
+    WindowManagerState* wms = display_manager()
+                                  ->GetWindowManagerAndDisplay(window)
+                                  .window_manager_state;
     wms->tree()->window_manager_internal_->WmSetBounds(
         wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id,
         std::move(bounds));
@@ -1074,9 +1083,9 @@ void WindowTree::SetWindowProperty(uint32_t change_id,
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         connection_manager_->GenerateWindowManagerChangeId(this, change_id);
-    WindowManagerState* wms =
-        connection_manager_->GetWindowManagerAndDisplay(window)
-            .window_manager_state;
+    WindowManagerState* wms = display_manager()
+                                  ->GetWindowManagerAndDisplay(window)
+                                  .window_manager_state;
     wms->tree()->window_manager_internal_->WmSetProperty(
         wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id, name,
         std::move(value));
diff --git a/components/mus/ws/window_tree.h b/components/mus/ws/window_tree.h
index fed9da0..5d2b73a 100644
--- a/components/mus/ws/window_tree.h
+++ b/components/mus/ws/window_tree.h
@@ -34,6 +34,7 @@ namespace ws {
 
 class AccessPolicy;
 class ConnectionManager;
+class DisplayManager;
 class Display;
 class ServerWindow;
 class TargetedEvent;
@@ -212,6 +213,9 @@ class WindowTree : public mojom::WindowTree,
     EMBED,
   };
 
+  DisplayManager* display_manager();
+  const DisplayManager* display_manager() const;
+
   // Used when this tree is the window manager.
   Display* GetDisplayForWindowManager();