chromeos: changes how DisplayManagerObservers are notified

services/ui/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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 265 matching lines @@
 }
 
 ServerWindow* WindowTree::ProcessSetDisplayRoot(
     const display::Display& display_to_create,
     const mojom::WmViewportMetrics& transport_viewport_metrics,
     bool is_primary_display,
     const ClientWindowId& client_window_id) {
   DCHECK(window_manager_state_);  // Only called for window manager.
   DVLOG(3) << "SetDisplayRoot client=" << id_
            << " global window_id=" << client_window_id.id;
-  Display* display =
-      window_server_->display_manager()->GetDisplayById(display_to_create.id());
+  Display* display = display_manager()->GetDisplayById(display_to_create.id());
   if (display) {
     DVLOG(1) << "SetDisplayRoot called with existing display "
              << display_to_create.id();
     return nullptr;
   }
 
   if (automatically_create_display_roots_) {
     DVLOG(1) << "SetDisplayRoot is only applicable when "
              << "automatically_create_display_roots is false";
     return nullptr;
   }
 
   ServerWindow* window = GetWindowByClientId(client_window_id);
   // The window must not have a parent.
   if (!window || window->parent()) {
     DVLOG(1) << "SetDisplayRoot called with invalid window id "
              << client_window_id.id;
     return nullptr;
   }
 
   if (base::ContainsValue(roots_, window)) {
     DVLOG(1) << "SetDisplayRoot called with existing root";
     return nullptr;
   }
 
-  const display::DisplayList::Type display_type =
-      is_primary_display ? display::DisplayList::Type::PRIMARY
-                         : display::DisplayList::Type::NOT_PRIMARY;
-  display::ScreenManager::GetInstance()->GetScreen()->display_list().AddDisplay(
-      display_to_create, display_type);
   display::ViewportMetrics viewport_metrics;
   viewport_metrics.bounds_in_pixels =
       transport_viewport_metrics.bounds_in_pixels;
   viewport_metrics.device_scale_factor =
       transport_viewport_metrics.device_scale_factor;
   viewport_metrics.ui_scale_factor = transport_viewport_metrics.ui_scale_factor;
-  window_server_->display_manager()->AddDisplayForWindowManager(
-      display_to_create, viewport_metrics);
-
-  // OnDisplayAdded() should trigger creation of the Display.
-  display =
-      window_server_->display_manager()->GetDisplayById(display_to_create.id());
+  display = display_manager()->AddDisplayForWindowManager(
+      is_primary_display, display_to_create, viewport_metrics);
   DCHECK(display);
   WindowManagerDisplayRoot* display_root =
       display->GetWindowManagerDisplayRootForUser(
           window_manager_state_->user_id());
   DCHECK(display_root);
   DCHECK(display_root->root()->children().empty());
 
   // NOTE: this doesn't resize the window in anyway. We assume the client takes
   // care of any modifications it needs to do.
   roots_.insert(window);
@@ skipping 808 matching lines @@
   const ServerWindow::Windows& children = window->children();
   for (ServerWindow* child : children)
     RemoveFromKnown(child, local_windows);
 }
 
 void WindowTree::RemoveRoot(ServerWindow* window, RemoveRootReason reason) {
   DCHECK(roots_.count(window) > 0);
   roots_.erase(window);
 
   if (window->id().client_id == id_) {
-    // This cllient created the window. If this client is the window manager and
+    // This client created the window. If this client is the window manager and
     // display roots are manually created, then |window| is a display root and
     // needs be cleaned.
     if (window_manager_state_ && !automatically_create_display_roots_) {
       // The window manager is asking to delete the root it created.
       window_manager_state_->DeleteWindowManagerDisplayRoot(window->parent());
       DeleteWindowImpl(this, window);
     }
     return;
   }
 
@@ skipping 804 matching lines @@
       window_manager_internal_client_binding_) {
     return;
   }
   window_manager_internal_client_binding_.reset(
       new mojo::AssociatedBinding<mojom::WindowManagerClient>(
           this, std::move(internal)));
 }
 
 void WindowTree::GetCursorLocationMemory(
     const GetCursorLocationMemoryCallback& callback) {
-  callback.Run(window_server_->display_manager()
+  callback.Run(display_manager()
                    ->GetCursorLocationManager(user_id_)
                    ->GetCursorLocationMemory());
 }
 
 void WindowTree::PerformDragDrop(
     uint32_t change_id,
     Id source_window_id,
     const gfx::Point& screen_location,
     const std::unordered_map<std::string, std::vector<uint8_t>>& drag_data,
     const SkBitmap& drag_image,
@@ skipping 201 matching lines @@
     WindowManagerDisplayRoot* display_root =
         GetWindowManagerDisplayRoot(focused_window);
     if (display_root->window_manager_state() != window_manager_state_.get()) {
       // We aren't active.
       return;
     }
     display_root->display()->ActivateNextWindow();
     return;
   }
   // Use the first display.
-  std::set<Display*> displays = window_server_->display_manager()->displays();
+  std::set<Display*> displays = display_manager()->displays();
   if (displays.empty())
     return;
 
   (*displays.begin())->ActivateNextWindow();
 }
 
 void WindowTree::SetExtendedHitArea(Id window_id, const gfx::Insets& hit_area) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   // Extended hit test region should only be set by the owner of the window.
   if (!window) {
@@ skipping 17 matching lines @@
       ProcessSetDisplayRoot(display, *viewport_metrics, is_primary_display,
                             ClientWindowId(window_id));
   if (!display_root) {
     callback.Run(base::nullopt);
     return;
   }
   display_root->parent()->SetVisible(true);
   callback.Run(display_root->current_local_surface_id());
 }
 
+void WindowTree::SetDisplayConfiguration(
+    const std::vector<display::Display>& displays,
+    std::vector<ui::mojom::WmViewportMetricsPtr> viewport_metrics,
+    int64_t primary_display_id,
+    const SetDisplayConfigurationCallback& callback) {
+  callback.Run(display_manager()->SetDisplayConfiguration(
+      displays, std::move(viewport_metrics), primary_display_id));
+}
+
 void WindowTree::WmResponse(uint32_t change_id, bool response) {
   if (window_server_->in_move_loop() &&
       window_server_->GetCurrentMoveLoopChangeId() == change_id) {
     ServerWindow* window = window_server_->GetCurrentMoveLoopWindow();
 
     if (window->id().client_id != id_) {
       window_server_->WindowManagerSentBogusMessage();
       window = nullptr;
     } else {
       WindowManagerDisplayRoot* display_root =
@@ skipping 250 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui