Handle modified displays in mustash.

ash/mus/window_manager.cc

 // Copyright 2015 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 "ash/mus/window_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "ash/mus/accelerators/accelerator_handler.h"
 #include "ash/mus/accelerators/accelerator_ids.h"
 #include "ash/mus/app_list_presenter_mus.h"
 #include "ash/mus/bridge/wm_lookup_mus.h"
 #include "ash/mus/bridge/wm_root_window_controller_mus.h"
 #include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/move_event_handler.h"
 #include "ash/mus/non_client_frame_controller.h"
 #include "ash/mus/property_util.h"
 #include "ash/mus/root_window_controller.h"
 #include "ash/mus/shadow_controller.h"
 #include "ash/mus/shell_delegate_mus.h"
 #include "ash/mus/window_manager_observer.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "base/memory/ptr_util.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/common/event_matcher_util.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/cpp/window.h"
 #include "services/ui/public/cpp/window_property.h"
 #include "services/ui/public/cpp/window_tree_client.h"
 #include "services/ui/public/interfaces/mus_constants.mojom.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/display_observer.h"
@@ skipping 10 matching lines @@
 WindowManager::~WindowManager() {
   Shutdown();
 }
 
 void WindowManager::Init(
     std::unique_ptr<ui::WindowTreeClient> window_tree_client,
     const scoped_refptr<base::SequencedWorkerPool>& blocking_pool) {
   DCHECK(!window_tree_client_);
   window_tree_client_ = std::move(window_tree_client);
 
+  // |connector_| will be null in some tests.
+  if (connector_)
+    connector_->ConnectToInterface("service:ui", &display_controller_);
+
   screen_ = base::MakeUnique<display::ScreenBase>();
 
   pointer_watcher_event_router_.reset(
       new views::PointerWatcherEventRouter(window_tree_client_.get()));
 
   shadow_controller_.reset(new ShadowController(window_tree_client_.get()));
 
   // The insets are roughly what is needed by CustomFrameView. The expectation
   // is at some point we'll write our own NonClientFrameView and get the insets
   // from it.
@@ skipping 62 matching lines @@
 }
 
 void WindowManager::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
+display::mojom::DisplayController* WindowManager::GetDisplayController() {
+  return display_controller_ ? display_controller_.get() : nullptr;
+}
+
 RootWindowController* WindowManager::CreateRootWindowController(
     ui::Window* window,
     const display::Display& display) {
   // CreateRootWindowController() means a new display is being added, so the
   // DisplayList needs to be updated. Calling AddDisplay() results in
   // notifying DisplayObservers. Ash code assumes when this happens there is
   // a valid RootWindowController for the new display. Suspend notifying
   // observers, add the Display, create the RootWindowController, and then
   // notify DisplayObservers. Classic ash does this by making sure
   // WindowTreeHostManager is added as a DisplayObserver early on.
@@ skipping 177 matching lines @@
                                    const display::Display& display) {
   CreateRootWindowController(window, display);
 }
 
 void WindowManager::OnWmDisplayRemoved(ui::Window* window) {
   auto iter = FindRootWindowControllerByWindow(window);
   DCHECK(iter != root_window_controllers_.end());
   DestroyRootWindowController(iter->get());
 }
 
+void WindowManager::OnWmDisplayModified(const display::Display& display) {
+  for (auto& controller : root_window_controllers_) {
+    if (controller->display().id() == display.id()) {
+      controller->SetDisplay(display);
+      // The root window will be resized by the window server.
+      return;
+    }
+  }
+
+  NOTREACHED();
+}
+
 void WindowManager::OnWmPerformMoveLoop(
     ui::Window* window,
     ui::mojom::MoveLoopSource source,
     const gfx::Point& cursor_location,
     const base::Callback<void(bool)>& on_done) {
   WmWindowMus* child_window = WmWindowMus::Get(window);
   MoveEventHandler* handler = MoveEventHandler::GetForWindow(child_window);
   if (!handler) {
     on_done.Run(false);
     return;
@@ skipping 18 matching lines @@
                                                     const ui::Event& event) {
   auto iter = accelerator_handlers_.find(GetAcceleratorNamespaceId(id));
   if (iter == accelerator_handlers_.end())
     return ui::mojom::EventResult::HANDLED;
 
   return iter->second->OnAccelerator(id, event);
 }
 
 }  // namespace mus
 }  // namespace ash