Adds ability to suspend notifying observers when display list is changed

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 16 matching lines @@
 #include "base/memory/ptr_util.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"
 #include "ui/events/mojo/event.mojom.h"
 #include "ui/views/mus/pointer_watcher_event_router.h"
 #include "ui/views/mus/screen_mus.h"
 
 namespace ash {
 namespace mus {
 
 WindowManager::WindowManager(shell::Connector* connector)
     : connector_(connector) {}
 
@@ skipping 83 matching lines @@
   observers_.AddObserver(observer);
 }
 
 void WindowManager::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 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.
+  std::unique_ptr<display::DisplayListObserverLock> display_lock =
+      screen_->display_list()->SuspendObserverUpdates();
+  const bool is_first_display = screen_->display_list()->displays().empty();
   // 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);
-  }
+  screen_->display_list()->AddDisplay(
+      display, is_first_display ? display::DisplayList::Type::PRIMARY
+                                : display::DisplayList::Type::NOT_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));
 
   FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                     OnRootWindowControllerAdded(root_window_controller));
 
-  if (!was_displays_empty) {
-    // 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);
-  }
+  FOR_EACH_OBSERVER(display::DisplayObserver,
+                    *screen_->display_list()->observers(),
+                    OnDisplayAdded(root_window_controller->display()));
+
   return root_window_controller;
 }
 
 void WindowManager::DestroyRootWindowController(
     RootWindowController* root_window_controller) {
   if (root_window_controllers_.size() > 1) {
     DCHECK_NE(root_window_controller, GetPrimaryRootWindowController());
     root_window_controller->wm_root_window_controller()->MoveWindowsTo(
         WmWindowMus::Get(GetPrimaryRootWindowController()->root()));
   }
@@ skipping 150 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