Add file thread in MessageHostContext.

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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 59 matching lines @@
 const int kMaxPortNumber = 12409;
 
 }  // namespace
 
 namespace remoting {
 
 class HostProcess : public OAuthClient::Delegate {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
-        file_io_thread_("FileIO"),
         allow_nat_traversal_(true),
         restarting_(false) {
-    file_io_thread_.StartWithOptions(
-        base::Thread::Options(MessageLoop::TYPE_IO, 0));
-
-    context_.reset(new ChromotingHostContext(
-                           file_io_thread_.message_loop_proxy(),
-                           message_loop_.message_loop_proxy()));
+    context_.reset(
+        new ChromotingHostContext(message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   }
 
   void InitWithCommandLine(const CommandLine* cmd_line) {
     FilePath default_config_dir = remoting::GetConfigDir();
     if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
       auth_config_path_ = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
     } else {
       auth_config_path_ = default_config_dir.Append(kDefaultAuthConfigFile);
     }
 
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     } else {
       host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
     }
 
 #if defined(OS_LINUX)
     Capturer::EnableXDamage(true);
 #endif
   }
 
   void ConfigUpdated() {
     // The auth tokens can't be updated once the host is running, so we don't
     // need to check the pending state, but it's a required parameter.
     bool tokens_pending;
-    if (LoadConfig(file_io_thread_.message_loop_proxy(), &tokens_pending)) {
+    if (LoadConfig(&tokens_pending)) {
       context_->network_message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&HostProcess::CreateAuthenticatorFactory,
                      base::Unretained(this)));
     } else {
       LOG(ERROR) << "Invalid configuration.";
     }
   }
 
 #if defined(OS_MACOSX)
   void ListenForConfigChanges() {
     remoting::RegisterHupSignalHandler(
         base::Bind(&HostProcess::ConfigUpdated, base::Unretained(this)));
   }
 #endif
 
   void CreateAuthenticatorFactory() {
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             xmpp_login_, key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
   int Run() {
     bool tokens_pending = false;
-    if (!LoadConfig(file_io_thread_.message_loop_proxy(), &tokens_pending)) {
+    if (!LoadConfig(&tokens_pending)) {
       return kInvalidHostConfigurationExitCode;
     }
     if (tokens_pending) {
       // If we have an OAuth refresh token, then XmppSignalStrategy can't
       // handle it directly, so refresh it asynchronously. A task will be
       // posted on the message loop to start watching the NAT policy when
       // the access token is available.
       //
       // TODO(sergeyu): Move this code to SignalingConnector.
       oauth_client_.Start(oauth_refresh_token_, this,
                           message_loop_.message_loop_proxy());
     } else {
       StartWatchingNatPolicy();
     }
 
 #if defined(OS_MACOSX)
-    file_io_thread_.message_loop_proxy()->PostTask(
+    context_->file_message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
     return kSuccessExitCode;
   }
 
   // Overridden from OAuthClient::Delegate
@@ skipping 14 matching lines @@
     }
   }
 
   virtual void OnOAuthError() OVERRIDE {
     LOG(ERROR) << "OAuth: invalid credentials.";
   }
 
  private:
   void StartWatchingNatPolicy() {
     nat_policy_.reset(
-        policy_hack::NatPolicy::Create(file_io_thread_.message_loop_proxy()));
+        policy_hack::NatPolicy::Create(
+            context_->file_message_loop()->message_loop_proxy()));
     nat_policy_->StartWatching(
         base::Bind(&HostProcess::OnNatPolicyUpdate, base::Unretained(this)));
   }
 
   // Read Host config from disk, returning true if successful.
-  bool LoadConfig(base::MessageLoopProxy* io_message_loop,
-                  bool* tokens_pending) {
+  bool LoadConfig(bool* tokens_pending) {
     JsonHostConfig host_config(host_config_path_);
     JsonHostConfig auth_config(auth_config_path_);
 
     FilePath failed_path;
     if (!host_config.Read()) {
       failed_path = host_config_path_;
     } else if (!auth_config.Read()) {
       failed_path = auth_config_path_;
     }
     if (!failed_path.empty()) {
@@ skipping 123 matching lines @@
 
     host_ = NULL;
     log_to_server_.reset();
     host_event_logger_.reset();
     heartbeat_sender_.reset();
 
     StartHost();
   }
 
   MessageLoop message_loop_;
-  base::Thread file_io_thread_;
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath auth_config_path_;
   FilePath host_config_path_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
@@ skipping 57 matching lines @@
 int CALLBACK WinMain(HINSTANCE instance,
                      HINSTANCE previous_instance,
                      LPSTR command_line,
                      int show_command) {
   // 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