Refators display related functionality into own class

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/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"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.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_root_id_(0),
+      display_manager_(new ws::DisplayManager(this)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       got_valid_frame_decorations_(false),
       window_manager_factory_registry_(this, &user_id_tracker_) {}
 
 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(
     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;
 }
 
 ConnectionSpecificId ConnectionManager::GetAndAdvanceNextConnectionId() {
   const ConnectionSpecificId id = next_connection_id_++;
   DCHECK_LT(id, next_connection_id_);
   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,
     mojom::WindowTreeClientPtr client) {
   scoped_ptr<WindowTree> tree_ptr(
       new ws::WindowTree(this, root, policy_bitmask));
   WindowTree* tree = tree_ptr.get();
 
   mojom::WindowTreePtr window_tree_ptr;
   scoped_ptr<WindowTreeBinding> binding =
@@ skipping 43 matching lines @@
     tree_map_.erase(iter);
   }
 
   // Notify remaining connections so that they can cleanup.
   for (auto& pair : tree_map_)
     pair.second->OnWindowDestroyingTreeImpl(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);
     }
   }
 
   // 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 == tree->id())
       to_remove.insert(pair.first);
   }
   for (uint32_t id : to_remove)
     in_flight_wm_change_map_.erase(id);
 }
 
 WindowTree* ConnectionManager::GetTreeWithId(
     ConnectionSpecificId connection_id) {
   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 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;
     }
   }
   WindowTree* tree = GetTreeWithId(id.connection_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) {
   if (current_operation_)
     current_operation_->MarkTreeAsMessaged(id);
 }
 
 bool ConnectionManager::DidTreeMessageClient(ConnectionSpecificId id) const {
   return current_operation_ && current_operation_->DidMessageTree(id);
 }
 
 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();
   return metrics;
 }
 
 const WindowTree* ConnectionManager::GetTreeWithRoot(
     const ServerWindow* window) const {
   if (!window)
     return nullptr;
   for (auto& pair : tree_map_) {
     if (pair.second->HasRoot(window))
       return pair.second.get();
   }
   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
   // created yet. Treat this as a signal to create a Display.
   // TODO(sky): we need a better way to determine this, most likely a switch.
   delegate_->CreateDefaultDisplays();
 }
 
 uint32_t ConnectionManager::GenerateWindowManagerChangeId(
     WindowTree* source,
@@ skipping 40 matching lines @@
     return;
   }
 
   tree->OnWindowManagerCreatedTopLevelWindow(window_manager_change_id,
                                              change.client_change_id, window);
 }
 
 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();
       display_ptr = mojom::Display::New();
       display_ptr->id = display->id();
       display_ptr->bounds = mojo::Rect::New();
       display_ptr->bounds->x = next_x;
       display_ptr->bounds->y = 0;
       display_ptr->bounds->width = root->bounds().size().width();
       display_ptr->bounds->height = root->bounds().size().height();
@@ skipping 74 matching lines @@
        OperationType::REMOVE_TRANSIENT_WINDOW_FROM_PARENT)) {
     return;
   }
   for (auto& pair : tree_map_) {
     pair.second->ProcessWindowReorder(window, relative_window, direction,
                                       IsOperationSource(pair.first));
   }
 }
 
 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(
     ServerWindow* window,
     int32_t cursor_id) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessCursorChanged(window, cursor_id,
                                       IsOperationSource(pair.first));
   }
 
   // Pass the cursor change to the native window.
-  Display* display = GetDisplayContaining(window);
+  Display* display = display_manager_->GetDisplayContaining(window);
   if (display)
     display->OnCursorUpdated(window);
 }
 
 void ConnectionManager::ProcessViewportMetricsChanged(
     Display* display,
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessViewportMetricsChanged(
@@ skipping 40 matching lines @@
 }
 
 void ConnectionManager::FinishOperation() {
   // PrepareForOperation/FinishOperation should be balanced.
   CHECK(current_operation_);
   current_operation_ = nullptr;
 }
 
 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(
     mojom::DisplayManagerObserver* observer,
     Display* display) {
   mojo::Array<mojom::DisplayPtr> displays(1);
   displays[0] = DisplayToMojomDisplay(display);
   display_manager_observers_.ForAllPtrs(
       [&displays](mojom::DisplayManagerObserver* observer) {
         observer->OnDisplaysChanged(displays.Clone());
       });
 }
 
 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(
     const ServerWindow* ancestor,
     mojom::SurfaceType surface_type,
     const ClientWindowId& client_window_id) {
   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;
   } else {
     window_tree = GetTreeWithId(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.
     WindowTree* tree_with_root = GetTreeWithRoot(ancestor);
     if (tree_with_root)
       window_tree = tree_with_root;
   }
   return window_tree->GetWindowByClientId(client_window_id);
 }
 
 void ConnectionManager::OnWindowDestroyed(ServerWindow* window) {
-  if (!in_destructor_)
-    ProcessWindowDeleted(window);
+  ProcessWindowDeleted(window);
 }
 
 void ConnectionManager::OnWillChangeWindowHierarchy(ServerWindow* window,
                                                     ServerWindow* new_parent,
                                                     ServerWindow* old_parent) {
   if (in_destructor_)
     return;
 
   ProcessWillChangeWindowHierarchy(window, new_parent, old_parent);
 }
@@ skipping 84 matching lines @@
     const std::vector<uint8_t>* new_data) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessWindowPropertyChanged(window, name, new_data,
                                               IsOperationSource(pair.first));
   }
 }
 
 void ConnectionManager::OnWindowTextInputStateChanged(
     ServerWindow* window,
     const ui::TextInputState& state) {
-  Display* display = GetDisplayContaining(window);
+  Display* display = display_manager_->GetDisplayContaining(window);
   display->UpdateTextInputState(window, state);
 }
 
 void ConnectionManager::OnTransientWindowAdded(ServerWindow* window,
                                                ServerWindow* transient_child) {
   for (auto& pair : tree_map_) {
     pair.second->ProcessTransientWindowAdded(window, transient_child,
                                              IsOperationSource(pair.first));
   }
 }
@@ skipping 17 matching lines @@
   // 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));
 }
 
+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