WIP: simplified display management in ash

ash/mus/test/wm_test_helper.cc

 // Copyright 2016 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/test/wm_test_helper.h"
 
 #include "ash/mus/screen_mus.h"
 #include "ash/mus/window_manager.h"
 #include "ash/mus/window_manager_application.h"
 #include "ash/public/cpp/config.h"
+#include "ash/shell.h"
 #include "ash/test/test_shell_delegate.h"
 #include "ash/wm_window.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/test/sequenced_worker_pool_owner.h"
+#include "services/ui/public/cpp/input_devices/input_device_client.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "ui/aura/mus/window_tree_client.h"
 #include "ui/aura/test/env_test_helper.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
 #include "ui/aura/window.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/test/material_design_controller_test_api.h"
 #include "ui/display/display.h"
 #include "ui/display/display_list.h"
 #include "ui/display/screen_base.h"
+#include "ui/display/test/display_manager_test_api.h"
 #include "ui/views/test/test_views_delegate.h"
 
 namespace ash {
 namespace mus {
 namespace {
 
 bool CompareByDisplayId(RootWindowController* root1,
                         RootWindowController* root2) {
   return root1->GetWindow()->GetDisplayNearestWindow().id() <
          root2->GetWindow()->GetDisplayNearestWindow().id();
@@ skipping 27 matching lines @@
   CHECK(base::StringToInt(size_parts[1], &h));
   bounds.set_size(gfx::Size(w, h));
   return bounds;
 }
 
 }  // namespace
 
 WmTestHelper::WmTestHelper() {}
 
 WmTestHelper::~WmTestHelper() {
+  // Flush the message loop so that any pending tasks are run. This ensures
+  // any delayed tasks, such as deleting RootWindowControllers, are processed
+  // before continuing.
+  base::RunLoop().RunUntilIdle();
+
   // Needs to be destroyed before material design.
   window_manager_app_.reset();
 
   base::RunLoop().RunUntilIdle();
   blocking_pool_owner_.reset();
   base::RunLoop().RunUntilIdle();
 
   ui::test::MaterialDesignControllerTestAPI::Uninitialize();
+
+  input_device_client_.reset();
 }
 
 void WmTestHelper::Init() {
+  const Config config = base::CommandLine::ForCurrentProcess()->HasSwitch("mus")
+                            ? Config::MUS
+                            : Config::MASH;
+  if (config == Config::MUS)
+    input_device_client_ = base::MakeUnique<ui::InputDeviceClient>();
+
   // MaterialDesignController may have already been initialized. To cover that
   // case explicitly uninitialize before initializing.
   ui::test::MaterialDesignControllerTestAPI::Uninitialize();
   ui::MaterialDesignController::Initialize();
 
   views_delegate_ = base::MakeUnique<views::TestViewsDelegate>();
 
-  window_manager_app_ = base::MakeUnique<WindowManagerApplication>();
+  const bool show_primary_host_on_connect = false;
+  window_manager_app_ =
+      base::MakeUnique<WindowManagerApplication>(show_primary_host_on_connect,
+                                                 config);
 
   message_loop_.reset(new base::MessageLoopForUI());
 
   const size_t kMaxNumberThreads = 3u;  // Matches that of content.
   const char kThreadNamePrefix[] = "MashBlockingForTesting";
   blocking_pool_owner_ = base::MakeUnique<base::SequencedWorkerPoolOwner>(
       kMaxNumberThreads, kThreadNamePrefix);
 
-  window_manager_app_->window_manager_ =
-      base::MakeUnique<WindowManager>(nullptr, Config::MASH);
+  window_manager_app_->window_manager_ = base::MakeUnique<WindowManager>(
+      nullptr, config, show_primary_host_on_connect);
   window_manager_app_->window_manager()->shell_delegate_ =
       base::MakeUnique<test::TestShellDelegate>();
 
   window_tree_client_setup_.InitForWindowManager(
       window_manager_app_->window_manager_.get(),
       window_manager_app_->window_manager_.get());
   aura::test::EnvTestHelper().SetWindowTreeClient(
       window_tree_client_setup_.window_tree_client());
   // See comment in AshTestHelper for details on why NetworkHandler is not
   // initialized.
   const bool init_network_handler = false;
   window_manager_app_->InitWindowManager(
       window_tree_client_setup_.OwnWindowTreeClient(),
       blocking_pool_owner_->pool(), init_network_handler);
 
   aura::WindowTreeClient* window_tree_client =
       window_manager_app_->window_manager()->window_tree_client();
   window_tree_client_private_ =
       base::MakeUnique<aura::WindowTreeClientPrivate>(window_tree_client);
-  int next_x = 0;
-  CreateRootWindowController("800x600", &next_x);
+  if (config == Config::MUS) {
+    window_tree_client_private_->CallOnConnect();
+  } else {
+    int next_x = 0;
+    CreateRootWindowController("800x600", &next_x);
+  }
 }
 
 std::vector<RootWindowController*> WmTestHelper::GetRootsOrderedByDisplayId() {
   std::set<RootWindowController*> roots =
       window_manager_app_->window_manager()->GetRootWindowControllers();
   std::vector<RootWindowController*> ordered_roots;
   ordered_roots.insert(ordered_roots.begin(), roots.begin(), roots.end());
   std::sort(ordered_roots.begin(), ordered_roots.end(), &CompareByDisplayId);
   return ordered_roots;
 }
 
 void WmTestHelper::UpdateDisplay(const std::string& display_spec) {
+  if (Shell::GetAshConfig() == Config::MUS) {
+    display::test::DisplayManagerTestApi(Shell::Get()->display_manager())
+        .UpdateDisplay(display_spec);
+    return;
+  }
   const std::vector<std::string> parts = base::SplitString(
       display_spec, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::vector<RootWindowController*> root_window_controllers =
       GetRootsOrderedByDisplayId();
   int next_x = 0;
   for (size_t i = 0,
               end = std::min(parts.size(), root_window_controllers.size());
        i < end; ++i) {
     UpdateDisplay(root_window_controllers[i], parts[i], &next_x);
   }
@@ skipping 41 matching lines @@
   const bool is_primary =
       screen->display_list().FindDisplayById(updated_display.id()) ==
       screen->display_list().GetPrimaryDisplayIterator();
   screen->display_list().UpdateDisplay(
       updated_display, is_primary ? display::DisplayList::Type::PRIMARY
                                   : display::DisplayList::Type::NOT_PRIMARY);
 }
 
 }  // namespace mus
 }  // namespace ash