mus/chrome: Always wait for the mojo shell.

content/browser/browser_main_loop.cc

 // Copyright (c) 2012 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 "content/browser/browser_main_loop.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 280 matching lines @@
     g_log_set_handler(kLogDomains[i],
                       static_cast<GLogLevelFlags>(G_LOG_FLAG_RECURSION |
                                                   G_LOG_FLAG_FATAL |
                                                   G_LOG_LEVEL_ERROR |
                                                   G_LOG_LEVEL_CRITICAL |
                                                   G_LOG_LEVEL_WARNING),
                       GLibLogHandler,
                       NULL);
   }
 }
-#endif
+#endif  // defined(USE_GLIB)
+
+#if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
+void WaitForMojoShellInitialize() {
+  base::RunLoop wait_loop;
+  MojoShellConnectionImpl::Get()->shell_connection()->set_initialize_handler(
+      wait_loop.QuitClosure());
+  wait_loop.Run();
+}
+#endif  // defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
 
 void OnStoppedStartupTracing(const base::FilePath& trace_file) {
   VLOG(0) << "Completed startup tracing to " << trace_file.value();
 }
 
 // Disable optimizations for this block of functions so the compiler doesn't
 // merge them all together. This makes it possible to tell what thread was
 // unresponsive by inspecting the callstack.
 MSVC_DISABLE_OPTIMIZE()
 MSVC_PUSH_DISABLE_WARNING(4748)
@@ skipping 871 matching lines @@
 
   if (IsRunningInMojoShell()) {
     if (!MojoShellConnectionImpl::CreateUsingFactory()) {
       mojo::edk::SetParentPipeHandleFromCommandLine();
       MojoShellConnectionImpl::Create();
       MojoShellConnectionImpl::Get()->BindToRequestFromCommandLine();
     }
 #if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
     MojoShellConnection* mojo_shell_connection = MojoShellConnection::Get();
     if (mojo_shell_connection) {
+      WaitForMojoShellInitialize();

[Ken Rockot(use gerrit already), 2016/04/26 03:28:55]

Do you think there may ever be a future where we can avoid blocking startup on
this connection? IIRC this is only needed because mus (or the window server, or
mus client code or... something, I don't remember) itself needs to completely
block the main thread until it receives some message, and that message can't be
received unless the shell connection has been initialized (which of course can't
happen while the main thread is blocked).

If this might be possible to avoid, please preserve my TODO from the other file
here. If not, I would like to understand why.

[sadrul, 2016/04/26 03:43:35]

I have added back the TODO.

It might be possible to avoid the blocking behaviour of
WindowManagerConnection/ScreenMus. One way would be to init with a default set
if displays in ScreenMus, and update local state when the mus-server sends back
information about the real set of displays to it asynchronously (instead of
blocking on the response). I plan on trying this out and see how well, if at
all, it works.

       views::WindowManagerConnection::Create(
           mojo_shell_connection->GetConnector(),
           mojo_shell_connection->GetIdentity());
     }
 #endif
   }
 
   mojo_shell_context_.reset(new MojoShellContext);
 #if defined(OS_MACOSX)
   mojo::edk::SetMachPortProvider(MachBroker::GetInstance());
@@ skipping 307 matching lines @@
   audio_task_runner = audio_thread_->task_runner();
   worker_task_runner = audio_thread_->task_runner();
   monitor_task_runner = io_thread_->task_runner();
 #endif  // defined(OS_MACOSX)
   audio_manager_ = media::AudioManager::Create(
       std::move(audio_task_runner), std::move(worker_task_runner),
       std::move(monitor_task_runner), MediaInternals::GetInstance());
 }
 
 }  // namespace content