Add (optional) options to Run[Main]Application().

mojo/application/run_application.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 "mojo/public/cpp/application/run_application.h"
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/debug/stack_trace.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_local_storage.h"
 #include "build/build_config.h"
+#include "mojo/application/run_application_options_chromium.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/application/application_impl_base.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
 namespace mojo {
 
 namespace {
 
 base::ThreadLocalStorage::StaticSlot g_current_result_holder = TLS_INITIALIZER;
 
 // We store a pointer to a |ResultHolder|, which just stores a |MojoResult|, in
 // TLS so that |TerminateApplication()| can provide the result that
 // |RunApplication()| will return. (The |ResultHolder| is just on
 // |RunApplication()|'s stack.)
 struct ResultHolder {
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   bool is_set = false;
 #endif
   // TODO(vtl): The default result should probably be |MOJO_RESULT_UNKNOWN|, but
   // |ApplicationRunnerChromium| always returned |MOJO_RESULT_OK|.
   MojoResult result = MOJO_RESULT_OK;
 };
 
 }  // namespace
 
 MojoResult RunMainApplication(MojoHandle application_request_handle,
-                              ApplicationImplBase* application_impl) {
+                              ApplicationImplBase* application_impl,
+                              const RunApplicationOptions* options) {
   base::CommandLine::Init(0, nullptr);
   base::AtExitManager at_exit;
 
   g_current_result_holder.Initialize(nullptr);
 
 #if !defined(NDEBUG) && !defined(OS_NACL)
   base::debug::EnableInProcessStackDumping();
 #endif
 
-  return RunApplication(application_request_handle, application_impl);
+  return RunApplication(application_request_handle, application_impl, options);
 }
 
 MojoResult RunApplication(MojoHandle application_request_handle,
-                          ApplicationImplBase* application_impl) {
+                          ApplicationImplBase* application_impl,
+                          const RunApplicationOptions* options) {
   DCHECK(!g_current_result_holder.Get());
 
   ResultHolder result_holder;
   g_current_result_holder.Set(&result_holder);
 
-  std::unique_ptr<base::MessageLoop> loop;
-  // TODO(vtl): Support other types of message loops. (That's why I'm leaving
-  // |loop| as a unique_ptr.)
-  loop.reset(new base::MessageLoop(common::MessagePumpMojo::Create()));
+  // Note: If |options| is non-null, it better point to a
+  // |RunApplicationOptionsChromium|.
+  base::MessageLoop::Type message_loop_type =
+      options
+          ? static_cast<const RunApplicationOptionsChromium*>(options)
+                ->message_loop_type
+          : base::MessageLoop::TYPE_CUSTOM;
+  std::unique_ptr<base::MessageLoop> loop(
+      (message_loop_type == base::MessageLoop::TYPE_CUSTOM)
+          ? new base::MessageLoop(common::MessagePumpMojo::Create())
+          : new base::MessageLoop(message_loop_type));
   application_impl->Bind(InterfaceRequest<Application>(
       MakeScopedHandle(MessagePipeHandle(application_request_handle))));
   loop->Run();
 
   g_current_result_holder.Set(nullptr);
 
   // TODO(vtl): We'd like to enable the following assertion, but we quit the
   // current message loop directly in various places.
   // DCHECK(result_holder.is_set);
 
@@ skipping 12 matching lines @@
       static_cast<ResultHolder*>(g_current_result_holder.Get());
   DCHECK(result_holder);
   DCHECK(!result_holder->is_set);
   result_holder->result = result;
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
   result_holder->is_set = true;
 #endif
 }
 
 }  // namespace mojo