mojo/application/public/cpp/lib/application_runner.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/application/public/cpp/application_runner.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/command_line.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/process/launch.h"
  12 #include "base/threading/worker_pool.h"
  13 #include "mojo/application/public/cpp/application_delegate.h"
  14 #include "mojo/application/public/cpp/application_impl.h"
  15 #include "mojo/message_pump/message_pump_mojo.h"
  16
  17 namespace mojo {
  18
  19 int g_application_runner_argc;
  20 const char* const* g_application_runner_argv;
  21
  22 ApplicationRunner::ApplicationRunner(ApplicationDelegate* delegate)
  23     : delegate_(scoped_ptr<ApplicationDelegate>(delegate)),
  24       message_loop_type_(base::MessageLoop::TYPE_CUSTOM),
  25       has_run_(false) {}
  26
  27 ApplicationRunner::~ApplicationRunner() {}
  28
  29 void ApplicationRunner::InitBaseCommandLine() {
  30   base::CommandLine::Init(g_application_runner_argc, g_application_runner_argv);
  31 }
  32
  33 void ApplicationRunner::set_message_loop_type(base::MessageLoop::Type type) {
  34   DCHECK_NE(base::MessageLoop::TYPE_CUSTOM, type);
  35   DCHECK(!has_run_);
  36
  37   message_loop_type_ = type;
  38 }
  39
  40 MojoResult ApplicationRunner::Run(MojoHandle application_request_handle,
  41                                   bool init_base) {
  42   DCHECK(!has_run_);
  43   has_run_ = true;
  44
  45   scoped_ptr<base::AtExitManager> at_exit;
  46   if (init_base) {
  47     InitBaseCommandLine();
  48     at_exit.reset(new base::AtExitManager);
  49   }
  50
  51   {
  52     scoped_ptr<base::MessageLoop> loop;
  53     if (message_loop_type_ == base::MessageLoop::TYPE_CUSTOM)
  54       loop.reset(new base::MessageLoop(common::MessagePumpMojo::Create()));
  55     else
  56       loop.reset(new base::MessageLoop(message_loop_type_));
  57
  58     ApplicationImpl impl(delegate_.get(),
  59                          MakeRequest<Application>(MakeScopedHandle(
  60                              MessagePipeHandle(application_request_handle))));
  61     loop->Run();
  62     // It's very common for the delegate to cache the app and terminate on
  63     // errors. If we don't delete the delegate before the app we run the risk
  64     // of the delegate having a stale reference to the app and trying to use it.
  65     // Note that we destruct the message loop first because that might trigger
  66     // connection error handlers and they might access objects created by the
  67     // delegate.
  68     loop.reset();
  69     delegate_.reset();
  70   }
  71
  72   // By default the worker pool continues running until all tasks are done or
  73   // the process is shut down. However, because the application could be
  74   // unloaded before process shutdown, we have to wait for the worker pool to
  75   // shut down cleanly.
  76   base::WorkerPool::ShutDownCleanly();
  77
  78   return MOJO_RESULT_OK;
  79 }
  80
  81 MojoResult ApplicationRunner::Run(MojoHandle application_request_handle) {
  82   return Run(application_request_handle, true);
  83 }
  84
  85 }  // namespace mojo