Promotes remaining global window manager state into WindowManagerState

components/mus/ws/window_server.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/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "components/mus/public/cpp/surfaces/surfaces_type_converters.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/global_window_manager_state.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_access_policy.h"
+#include "components/mus/ws/window_manager_display_root.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_manager_window_tree_factory.h"
 #include "components/mus/ws/window_server_delegate.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "services/shell/public/cpp/connection.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace mus {
 namespace ws {
 
 WindowServer::WindowServer(
     WindowServerDelegate* delegate,
     const scoped_refptr<mus::SurfacesState>& surfaces_state)
     : delegate_(delegate),
       surfaces_state_(surfaces_state),
       next_client_id_(1),
-      display_manager_(new DisplayManager(this)),
+      display_manager_(new DisplayManager(this, &user_id_tracker_)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       window_manager_window_tree_factory_set_(this, &user_id_tracker_) {}
 
 WindowServer::~WindowServer() {
   in_destructor_ = true;
 
   // 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
@@ skipping 374 matching lines @@
   current_operation_ = op;
 }
 
 void WindowServer::FinishOperation() {
   // PrepareForOperation/FinishOperation should be balanced.
   CHECK(current_operation_);
   current_operation_ = nullptr;
 }
 
 void WindowServer::UpdateNativeCursorFromMouseLocation(ServerWindow* window) {
-  WindowManagerAndDisplay wm_and_display =
-      display_manager_->GetWindowManagerAndDisplay(window);
-  WindowManagerState* wms = wm_and_display.window_manager_state;
-  if (wms && wm_and_display.display) {
-    wms->event_dispatcher()->UpdateCursorProviderByLastKnownLocation();
+  WindowManagerDisplayRoot* display_root =
+      display_manager_->GetWindowManagerDisplayRoot(window);
+  if (display_root) {
+    EventDispatcher* event_dispatcher =
+        display_root->window_manager_state()->event_dispatcher();
+    event_dispatcher->UpdateCursorProviderByLastKnownLocation();
     int32_t cursor_id = 0;
-    if (wms->event_dispatcher()->GetCurrentMouseCursor(&cursor_id))
-      wm_and_display.display->UpdateNativeCursor(cursor_id);
+    if (event_dispatcher->GetCurrentMouseCursor(&cursor_id))
+      display_root->display()->UpdateNativeCursor(cursor_id);
   }
 }
 
 void WindowServer::UpdateNativeCursorIfOver(ServerWindow* window) {
-  WindowManagerAndDisplay wm_and_display =
-      display_manager_->GetWindowManagerAndDisplay(window);
-  WindowManagerState* wms = wm_and_display.window_manager_state;
-  if (wms && wm_and_display.display &&
-      window == wms->event_dispatcher()->mouse_cursor_source_window()) {
-    wms->event_dispatcher()->UpdateNonClientAreaForCurrentWindow();
-    int32_t cursor_id = 0;
-    if (wms->event_dispatcher()->GetCurrentMouseCursor(&cursor_id))
-      wm_and_display.display->UpdateNativeCursor(cursor_id);
-  }
+  WindowManagerDisplayRoot* display_root =
+      display_manager_->GetWindowManagerDisplayRoot(window);
+  if (!display_root)
+    return;
+
+  EventDispatcher* event_dispatcher =
+      display_root->window_manager_state()->event_dispatcher();
+  if (window != event_dispatcher->mouse_cursor_source_window())
+    return;
+
+  event_dispatcher->UpdateNonClientAreaForCurrentWindow();
+  int32_t cursor_id = 0;
+  if (event_dispatcher->GetCurrentMouseCursor(&cursor_id))
+    display_root->display()->UpdateNativeCursor(cursor_id);
 }
 
 mus::SurfacesState* WindowServer::GetSurfacesState() {
   return surfaces_state_.get();
 }
 
 void WindowServer::OnScheduleWindowPaint(ServerWindow* window) {
   if (in_destructor_)
     return;
 
@@ skipping 26 matching lines @@
 
   ProcessWillChangeWindowHierarchy(window, new_parent, old_parent);
 }
 
 void WindowServer::OnWindowHierarchyChanged(ServerWindow* window,
                                             ServerWindow* new_parent,
                                             ServerWindow* old_parent) {
   if (in_destructor_)
     return;
 
-  WindowManagerState* wms =
-      display_manager_->GetWindowManagerAndDisplay(window).window_manager_state;
-  if (wms)
-    wms->ReleaseCaptureBlockedByAnyModalWindow();
+  WindowManagerDisplayRoot* display_root =
+      display_manager_->GetWindowManagerDisplayRoot(window);
+  if (display_root)
+    display_root->window_manager_state()
+        ->ReleaseCaptureBlockedByAnyModalWindow();
 
   ProcessWindowHierarchyChanged(window, new_parent, old_parent);
 
   // TODO(beng): optimize.
   if (old_parent)
     SchedulePaint(old_parent, gfx::Rect(old_parent->bounds().size()));
   if (new_parent)
     SchedulePaint(new_parent, gfx::Rect(new_parent->bounds().size()));
 
   UpdateNativeCursorFromMouseLocation(window);
@@ skipping 63 matching lines @@
   for (auto& pair : tree_map_) {
     pair.second->ProcessWindowOpacityChanged(window, old_opacity, new_opacity,
                                              IsOperationSource(pair.first));
   }
 }
 
 void WindowServer::OnWindowVisibilityChanged(ServerWindow* window) {
   if (in_destructor_)
     return;
 
-  WindowManagerState* wms =
-      display_manager_->GetWindowManagerAndDisplay(window).window_manager_state;
-  if (wms)
-    wms->ReleaseCaptureBlockedByModalWindow(window);
+  WindowManagerDisplayRoot* display_root =
+      display_manager_->GetWindowManagerDisplayRoot(window);
+  if (display_root)
+    display_root->window_manager_state()->ReleaseCaptureBlockedByModalWindow(
+        window);
 }
 
 void WindowServer::OnWindowPredefinedCursorChanged(ServerWindow* window,
                                                    int32_t cursor_id) {
   if (in_destructor_)
     return;
 
   ProcessWillChangeWindowPredefinedCursor(window, cursor_id);
 
   UpdateNativeCursorIfOver(window);
@@ skipping 37 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 : tree_map_) {
     pair.second->ProcessTransientWindowRemoved(window, transient_child,
                                                IsOperationSource(pair.first));
   }
 }
 
 void WindowServer::OnFirstDisplayReady() {
-  // TODO(sky): remove this, temporary until window manager state made
-  // global.
-  if (!created_one_display_) {
-    created_one_display_ = true;
-    std::vector<WindowManagerWindowTreeFactory*> factories =
-        window_manager_window_tree_factory_set_.GetFactories();
-    for (WindowManagerWindowTreeFactory* factory : factories)
-      factory->BindPendingRequest();
-  }
   delegate_->OnFirstDisplayReady();
 }
 
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 bool WindowServer::GetFrameDecorationsForUser(
     const UserId& user_id,
     mojom::FrameDecorationValuesPtr* values) {
-  GlobalWindowManagerState* global_window_manager_state =
-      window_manager_window_tree_factory_set_
-          .GetGlobalWindowManagerStateForUser(user_id);
-  if (!global_window_manager_state)
+  WindowManagerState* window_manager_state =
+      window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
+          user_id);
+  if (!window_manager_state)
     return false;
-  if (values && global_window_manager_state->got_frame_decoration_values())
-    *values = global_window_manager_state->frame_decoration_values().Clone();
-  return global_window_manager_state->got_frame_decoration_values();
+  if (values && window_manager_state->got_frame_decoration_values())
+    *values = window_manager_state->frame_decoration_values().Clone();
+  return window_manager_state->got_frame_decoration_values();
+}
+
+WindowManagerState* WindowServer::GetWindowManagerStateForUser(
+    const UserId& user_id) {
+  return window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
+      user_id);
 }
 
 }  // namespace ws
 }  // namespace mus