Promotes remaining global window manager state into WindowManagerState

components/mus/mus_app.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 "components/mus/mus_app.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 50 matching lines @@
 
 const char kResourceFileStrings[] = "mus_app_resources_strings.pak";
 const char kResourceFile100[] = "mus_app_resources_100.pak";
 const char kResourceFile200[] = "mus_app_resources_200.pak";
 
 }  // namespace
 
 // TODO(sky): this is a pretty typical pattern, make it easier to do.
 struct MusApp::PendingRequest {
   shell::Connection* connection;
-  std::unique_ptr<mojo::InterfaceRequest<mojom::WindowTreeFactory>> wtf_request;
+  std::unique_ptr<mojom::WindowTreeFactoryRequest> wtf_request;
+  std::unique_ptr<mojom::DisplayManagerRequest> dm_request;
 };
 
 struct MusApp::UserState {
   std::unique_ptr<clipboard::ClipboardImpl> clipboard;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 MusApp::MusApp()
     : test_config_(false),
       use_chrome_gpu_command_buffer_(false),
@@ skipping 150 matching lines @@
 #if defined(USE_OZONE)
   ui::OzonePlatform::GetInstance()->AddInterfaces(connection);
 #endif
 
   return true;
 }
 
 void MusApp::OnFirstDisplayReady() {
   PendingRequests requests;
   requests.swap(pending_requests_);
-  for (auto& request : requests)
-    Create(request->connection, std::move(*request->wtf_request));
+  for (auto& request : requests) {
+    if (request->wtf_request)
+      Create(request->connection, std::move(*request->wtf_request));
+    else
+      Create(request->connection, std::move(*request->dm_request));
+  }
 }
 
 void MusApp::OnNoMoreDisplays() {
   // We may get here from the destructor, in which case there is no messageloop.
   if (base::MessageLoop::current())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 bool MusApp::IsTestConfig() const {
   return test_config_;
 }
 
 void MusApp::CreateDefaultDisplays() {
   // An asynchronous callback will create the Displays once the physical
   // displays are ready.
   platform_screen_->ConfigurePhysicalDisplay(base::Bind(
       &MusApp::OnCreatedPhysicalDisplay, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MusApp::Create(shell::Connection* connection,
                     mojom::ClipboardRequest request) {
   UserState* user_state = GetUserState(connection);
   if (!user_state->clipboard)
     user_state->clipboard.reset(new clipboard::ClipboardImpl);
   user_state->clipboard->AddBinding(std::move(request));
 }
 
 void MusApp::Create(shell::Connection* connection,
                     mojom::DisplayManagerRequest request) {
+  // DisplayManagerObservers generally expect there to be at least one display.
+  if (!window_server_->display_manager()->has_displays()) {
+    std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
+    pending_request->connection = connection;
+    pending_request->dm_request.reset(
+        new mojom::DisplayManagerRequest(std::move(request)));
+    pending_requests_.push_back(std::move(pending_request));
+    return;
+  }
   window_server_->display_manager()
       ->GetUserDisplayManager(connection->GetRemoteIdentity().user_id())
       ->AddDisplayManagerBinding(std::move(request));
 }
 
 void MusApp::Create(shell::Connection* connection, mojom::GpuRequest request) {
   if (use_chrome_gpu_command_buffer_)
     return;
   DCHECK(platform_display_init_params_.gpu_state);
   new GpuImpl(std::move(request), platform_display_init_params_.gpu_state);
@@ skipping 18 matching lines @@
       connection->GetRemoteIdentity().user_id(), std::move(request));
 }
 
 void MusApp::Create(Connection* connection,
                     mojom::WindowTreeFactoryRequest request) {
   AddUserIfNecessary(connection);
   if (!window_server_->display_manager()->has_displays()) {
     std::unique_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->connection = connection;
     pending_request->wtf_request.reset(
-        new mojo::InterfaceRequest<mojom::WindowTreeFactory>(
-            std::move(request)));
+        new mojom::WindowTreeFactoryRequest(std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   AddUserIfNecessary(connection);
   new ws::WindowTreeFactory(
       window_server_.get(), connection->GetRemoteIdentity().user_id(),
       connection->GetRemoteIdentity().name(), std::move(request));
 }
 
 void MusApp::Create(Connection* connection,
@@ skipping 21 matching lines @@
   // Display manages its own lifetime.
   ws::Display* host_impl =
       new ws::Display(window_server_.get(), platform_display_init_params_);
   host_impl->Init(nullptr);
 
   if (touch_controller_)
     touch_controller_->UpdateTouchTransforms();
 }
 
 }  // namespace mus