[Chromoting] Introducing refcount-based life time management of the message loops in the service (d…

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/ssl_server_socket.h"
+#include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/composite_host_config.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
@@ skipping 49 matching lines @@
 const int kMaxPortNumber = 12409;
 
 const char kUnofficialOAuth2ClientId[] =
     "440925447803-2pi3v45bff6tp1rde2f7q6lgbor3o5uj.apps.googleusercontent.com";
 const char kUnofficialOAuth2ClientSecret[] = "W2ieEsG-R1gIA4MMurGrgMc_";
 
 const char kOfficialOAuth2ClientId[] =
     "440925447803-avn2sj1kc099s0r7v62je5s339mu0am1.apps.googleusercontent.com";
 const char kOfficialOAuth2ClientSecret[] = "Bgur6DFiOMM1h8x-AQpuTQlK";
 
+void QuitMessageLoop(MessageLoop* message_loop) {
+  message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+}
+
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
     : public HeartbeatSender::Listener,
       public IPC::Listener {
  public:
-  HostProcess()
-      : message_loop_(MessageLoop::TYPE_UI),
+  HostProcess(scoped_ptr<ChromotingHostContext> context)
+      : context_(context.Pass()),
 #ifdef OFFICIAL_BUILD
         oauth_use_official_client_id_(true),
 #else
         oauth_use_official_client_id_(false),
 #endif
         allow_nat_traversal_(true),
         restarting_(false),
         shutting_down_(false),
         exit_code_(kSuccessExitCode)
 #if defined(OS_MACOSX)
       , curtain_(base::Bind(&HostProcess::OnDisconnectRequested,
                             base::Unretained(this)),
                  base::Bind(&HostProcess::OnDisconnectRequested,
                             base::Unretained(this)))
 #endif
   {
-    context_.reset(
-        new ChromotingHostContext(message_loop_.message_loop_proxy()));
-    context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     config_updated_timer_.reset(new base::DelayTimer<HostProcess>(
         FROM_HERE, base::TimeDelta::FromSeconds(2), this,
         &HostProcess::ConfigUpdatedDelayed));
   }
 
   bool InitWithCommandLine(const CommandLine* cmd_line) {
     // Connect to the daemon process.
     std::string channel_name =
         cmd_line->GetSwitchValueASCII(kDaemonIpcSwitchName);
@@ skipping 18 matching lines @@
     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     }
     config_.AddConfigPath(host_config_path_);
 
     return true;
   }
 
   void ConfigUpdated() {
-    DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     // Call ConfigUpdatedDelayed after a short delay, so that this object won't
     // try to read the updated configuration file before it has been
     // completely written.
     // If the writer moves the new configuration file into place atomically,
     // this delay may not be necessary.
     config_updated_timer_->Reset();
   }
 
   void ConfigUpdatedDelayed() {
-    DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     if (LoadConfig()) {
       // PostTask to create new authenticator factory in case PIN has changed.
       context_->network_task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&HostProcess::CreateAuthenticatorFactory,
                      base::Unretained(this)));
     } else {
       LOG(ERROR) << "Invalid configuration.";
     }
@@ skipping 24 matching lines @@
   };
 #endif  // defined(OS_WIN)
 
   void ListenForConfigChanges() {
 #if defined(OS_POSIX)
     remoting::RegisterHupSignalHandler(
         base::Bind(&HostProcess::ConfigUpdatedDelayed, base::Unretained(this)));
 #elif defined(OS_WIN)
     scoped_refptr<base::files::FilePathWatcher::Delegate> delegate(
         new ConfigChangedDelegate(
-            message_loop_.message_loop_proxy(),
+            context_->ui_task_runner(),
             base::Bind(&HostProcess::ConfigUpdated, base::Unretained(this))));
     config_watcher_.reset(new base::files::FilePathWatcher());
     if (!config_watcher_->Watch(host_config_path_, delegate)) {
       LOG(ERROR) << "Couldn't watch file " << host_config_path_.value();
     }
 #endif  // defined (OS_WIN)
   }
 
   void CreateAuthenticatorFactory() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) {
     return false;
   }
 
-  int Run() {
-    if (!LoadConfig()) {
-      return kInvalidHostConfigurationExitCode;
+  void StartHostProcess() {
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
+
+    if (!InitWithCommandLine(CommandLine::ForCurrentProcess()) ||
+        !LoadConfig()) {
+      context_->network_task_runner()->PostTask(
+          FROM_HERE,
+          base::Bind(&HostProcess::Shutdown, base::Unretained(this),
+                     kInvalidHostConfigurationExitCode));
+      return;
     }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset(new HostUserInterface(context_.get()));
 #endif
 
     StartWatchingPolicy();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
-    message_loop_.Run();
+  }
+
+  int get_exit_code() const { return exit_code_; }
+
+ private:
+  void ShutdownHostProcess() {
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
+
+    daemon_channel_.reset();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
-    daemon_channel_.reset();
-    base::WaitableEvent done_event(true, false);
-    policy_watcher_->StopWatching(&done_event);
-    done_event.Wait();
-    policy_watcher_.reset();
+    if (policy_watcher_.get()) {
+      base::WaitableEvent done_event(true, false);
+      policy_watcher_->StopWatching(&done_event);
+      done_event.Wait();
+      policy_watcher_.reset();
+    }
 
-    return exit_code_;
+    context_.reset();
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
     LOG(ERROR) << "Host ID not found.";
     Shutdown(kInvalidHostIdExitCode);
   }
 
- private:
   void StartWatchingPolicy() {
     policy_watcher_.reset(
         policy_hack::PolicyWatcher::Create(context_->file_task_runner()));
     policy_watcher_->StartWatching(
         base::Bind(&HostProcess::OnPolicyUpdate, base::Unretained(this)));
   }
 
   // Read host config, returning true if successful.
   bool LoadConfig() {
-    DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     // TODO(sergeyu): There is a potential race condition: this function is
     // called on the main thread while the class members it mutates are used on
     // the network thread. Fix it. http://crbug.com/140986 .
 
     if (!config_.Read()) {
       LOG(ERROR) << "Failed to read config file.";
       return false;
     }
 
@@ skipping 225 matching lines @@
     CreateAuthenticatorFactory();
   }
 
   void OnAuthFailed() {
     Shutdown(kInvalidOauthCredentialsExitCode);
   }
 
   // Invoked when the user uses the Disconnect windows to terminate
   // the sessions.
   void OnDisconnectRequested() {
-    DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
+    DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     host_->DisconnectAllClients();
   }
 
   void RestartHost() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (restarting_ || shutting_down_)
       return;
 
@@ skipping 31 matching lines @@
     } else {
       OnShutdownFinished();
     }
   }
 
   void OnShutdownFinished() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     // Destroy networking objects while we are on the network thread.
     host_ = NULL;
+    desktop_environment_.reset();
     host_event_logger_.reset();
     log_to_server_.reset();
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
 
-    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    // Complete the rest of shutdown on the main thread.
+    context_->ui_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&HostProcess::ShutdownHostProcess,
+                   base::Unretained(this)));
   }
 
-  MessageLoop message_loop_;
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath host_config_path_;
   CompositeHostConfig config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
@@ skipping 53 matching lines @@
   InitLogging(debug_log.value().c_str(),
 #if defined(OS_WIN)
               logging::LOG_ONLY_TO_FILE,
 #else
               logging::LOG_ONLY_TO_SYSTEM_DEBUG_LOG,
 #endif
               logging::DONT_LOCK_LOG_FILE,
               logging::APPEND_TO_OLD_LOG_FILE,
               logging::DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS);
 
-  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-
 #if defined(TOOLKIT_GTK)
   // Required for any calls into GTK functions, such as the Disconnect and
   // Continue windows, though these should not be used for the Me2Me case
   // (crbug.com/104377).
+  const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_GTK
 
   // Enable support for SSL server sockets, which must be done while still
   // single-threaded.
   net::EnableSSLServerSockets();
 
 #if defined(OS_LINUX)
-    remoting::VideoFrameCapturer::EnableXDamage(true);
+  remoting::VideoFrameCapturer::EnableXDamage(true);
 #endif
 
-  remoting::HostProcess me2me_host;
-  if (!me2me_host.InitWithCommandLine(cmd_line)) {
-    return remoting::kInvalidHostConfigurationExitCode;
-  }
+  // Create the main message loop and start helper threads.
+  MessageLoop message_loop(MessageLoop::TYPE_UI);
+  base::Closure quit_message_loop = base::Bind(&QuitMessageLoop,
+                                              base::Unretained(&message_loop));

[Sergey Ulanov, 2012/08/31 01:25:18]

Do you really need Unretained here given that QuitMessageLoop is not a method?

[alexeypa (please no reviews), 2012/08/31 19:57:36]

Done.

+  scoped_ptr<remoting::ChromotingHostContext> context(
+      new remoting::ChromotingHostContext(
+          new remoting::AutoThreadTaskRunner(message_loop.message_loop_proxy(),
+                                             quit_message_loop)));
+  if (!context->Start())
+    return remoting::kHostInitializationFailed;
 
-  return me2me_host.Run();
+  // Create the host process instance and run the rest of the initialization on
+  // the main message loop.
+  remoting::HostProcess me2me_host(context.Pass());
+  message_loop.PostTask(
+      FROM_HERE,
+      base::Bind(&remoting::HostProcess::StartHostProcess,
+                 base::Unretained(&me2me_host)));
+  message_loop.Run();
+  return me2me_host.get_exit_code();
 }
 
 #if defined(OS_WIN)
 HMODULE g_hModule = NULL;
 
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
 #ifdef OFFICIAL_BUILD
@@ skipping 23 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)