Adds support for multiple displays to WmTestBase

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>
 
@@ skipping 61 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);
 
+  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.
   ui::mojom::FrameDecorationValuesPtr frame_decoration_values =
       ui::mojom::FrameDecorationValues::New();
@@ skipping 63 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 RootWindowController* WindowManager::CreateRootWindowController(
     ui::Window* window,
     const display::Display& display) {
-  // TODO(sky): There are timing issues with using ScreenMus.
-  if (!screen_) {
-    std::unique_ptr<views::ScreenMus> screen(new views::ScreenMus(nullptr));
-    screen->Init(connector_);
-    screen_ = std::move(screen);
+  // TODO(sky): should be passed whether display is primary.
+
+  // There needs to be at least one display before creating
+  // RootWindowController, otherwise initializing the compositor fails.
+  const bool was_displays_empty = screen_->display_list()->displays().empty();
+  if (was_displays_empty) {
+    screen_->display_list()->AddDisplay(display,
+                                        display::DisplayList::Type::PRIMARY);
   }
 
   std::unique_ptr<RootWindowController> root_window_controller_ptr(
       new RootWindowController(this, window, display));
   RootWindowController* root_window_controller =
       root_window_controller_ptr.get();
   root_window_controllers_.insert(std::move(root_window_controller_ptr));
   window->AddObserver(this);
 
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnRootWindowControllerAdded(root_window_controller));
+
+  if (!was_displays_empty) {

[msw, 2016/09/12 23:19:48]

nit: unconditionally add the display above?

[sky, 2016/09/13 00:10:26]

Sadly it has to be like this, and I suspect even this is fragile. I've added a
comment as to why we have to add after the fact:

    // If this isn't the initial display then add the display to Screen after
    // creating the RootWindowController. We need to do this after creating the
    // RootWindowController as adding the display triggers OnDisplayAdded(),
    // which triggers some overrides asking for the RootWindowController for the
    // new display.

+    screen_->display_list()->AddDisplay(
+        display, display::DisplayList::Type::NOT_PRIMARY);
+  }
   return root_window_controller;
 }
 
+void WindowManager::DestroyRootWindowController(
+    RootWindowController* root_window_controller) {
+  // TODO(sky): WindowManager shouldn't need to observe the windows. Instead
+  // WindowManager should have a specific API that is called when a display is
+  // removed.
+  ui::Window* root_window = root_window_controller->root();
+  auto it = FindRootWindowControllerByWindow(root_window);
+  DCHECK(it != root_window_controllers_.end());
+  FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
+                    OnWillDestroyRootWindowController((*it).get()));
+  root_window_controllers_.erase(it);
+  // Remove the observer so we don't see the OnWindowDestroying/Destroyed as we
+  // already handled it here.
+  root_window->RemoveObserver(this);
+  root_window->Destroy();
+}
+
 void WindowManager::Shutdown() {
   if (!window_tree_client_)
     return;
 
   // Observers can rely on WmShell from the callback. So notify the observers
   // before destroying it.
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnWindowTreeClientDestroyed());
 
   // Destroy the roots of the RootWindowControllers, which triggers removal
   // in OnWindowDestroyed().
   while (!root_window_controllers_.empty())
     (*root_window_controllers_.begin())->root()->Destroy();
 
   lookup_.reset();
   shell_->Shutdown();
   shell_.reset();
   shadow_controller_.reset();
 
   pointer_watcher_event_router_.reset();
 
   window_tree_client_.reset();
   window_manager_client_ = nullptr;
 }
 
-void WindowManager::OnWindowDestroying(ui::Window* window) {
+WindowManager::RootWindowControllers::iterator
+WindowManager::FindRootWindowControllerByWindow(ui::Window* window) {
   for (auto it = root_window_controllers_.begin();
        it != root_window_controllers_.end(); ++it) {
-    if ((*it)->root() == window) {
-      FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
-                        OnWillDestroyRootWindowController((*it).get()));
-      return;
-    }
+    if ((*it)->root() == window)
+      return it;
   }
-  NOTREACHED();
+  return root_window_controllers_.end();
+}
+
+void WindowManager::OnWindowDestroying(ui::Window* window) {
+  auto it = FindRootWindowControllerByWindow(window);
+  DCHECK(it != root_window_controllers_.end());
+  FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
+                    OnWillDestroyRootWindowController((*it).get()));
 }
 
 void WindowManager::OnWindowDestroyed(ui::Window* window) {
+  auto it = FindRootWindowControllerByWindow(window);
+  DCHECK(it != root_window_controllers_.end());
   window->RemoveObserver(this);
-  for (auto it = root_window_controllers_.begin();
-       it != root_window_controllers_.end(); ++it) {
-    if ((*it)->root() == window) {
-      root_window_controllers_.erase(it);
-      return;
-    }
-  }
-  NOTREACHED();
+  root_window_controllers_.erase(it);
 }
 
 void WindowManager::OnEmbed(ui::Window* root) {
   // WindowManager should never see this, instead OnWmNewDisplay() is called.
   NOTREACHED();
 }
 
 void WindowManager::OnEmbedRootDestroyed(ui::Window* root) {
   // WindowManager should never see this.
   NOTREACHED();
@@ skipping 83 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