Refators display related functionality into own class

components/mus/ws/window_tree.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_tree.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #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"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/window_manager_access_policy.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/ime/ime_type_converters.h"
@@ skipping 121 matching lines @@
 }
 
 const ServerWindow* WindowTree::GetWindowByClientId(
     const ClientWindowId& id) const {
   auto iter = client_id_to_window_id_map_.find(id);
   return iter == client_id_to_window_id_map_.end() ? nullptr
                                                    : GetWindow(iter->second);
 }
 
 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) {
   // Notify our client if |tree| was embedded in any of our views.
   for (const auto* tree_root : tree->roots_) {
     const bool owns_tree_root = tree_root->id().connection_id == id_;
     if (owns_tree_root || (is_embed_root_ && IsWindowKnown(tree_root))) {
       client()->OnEmbeddedAppDisconnected(
           ClientWindowIdForWindow(tree_root).id);
     }
@@ skipping 388 matching lines @@
     return;
   ClientWindowId client_window_id, transient_client_window_id;
   if (!IsWindowKnown(window, &client_window_id) ||
       !IsWindowKnown(transient_window, &transient_client_window_id)) {
     return;
   }
   client()->OnTransientWindowRemoved(client_window_id.id,
                                      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());
 
   // Indicates this connection is for the wm.
   DCHECK(window_manager_internal_);
 
   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());
   return display;
 }
 
 bool WindowTree::ShouldRouteToWindowManager(const ServerWindow* window) const {
   // If the client created this window, then do not route it through the WM.
   if (window->id().connection_id == id_)
     return false;
 
   // If the client did not create the window, then it must be the root of the
   // client. If not, that means the client should not know about this window,
   // and so do not route the request to the WM.
   if (roots_.count(window) == 0)
     return false;
 
   // 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;
 
   // Requests coming from the WM should not be routed through the WM again.
   const bool is_wm = wms->tree() == this;
   return is_wm ? false : true;
 }
 
 void WindowTree::ProcessLostCapture(const ServerWindow* old_capture_window,
                                     bool originated_change) {
@@ skipping 276 matching lines @@
   client()->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTree::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
     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;
   if (!wms || wms->tree() == this || !IsValidIdForNewWindow(client_window_id)) {
     client()->OnChangeCompleted(change_id, false);
     return;
   }
 
   // The server creates the real window. Any further messages from the client
   // may try to alter the window. Pause incoming messages so that we know we
@@ skipping 127 matching lines @@
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
                                  mojo::RectPtr bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_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));
     return;
   }
 
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_WINDOW_BOUNDS);
@@ skipping 12 matching lines @@
 
 void WindowTree::SetWindowProperty(uint32_t change_id,
                                    Id transport_window_id,
                                    const mojo::String& name,
                                    mojo::Array<uint8_t> value) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_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));
     return;
   }
   const bool success = window && access_policy_->CanSetWindowProperties(window);
   if (success) {
     Operation op(this, connection_manager_, OperationType::SET_WINDOW_PROPERTY);
     if (value.is_null()) {
       window->SetProperty(name, nullptr);
@@ skipping 268 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus