Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

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 128 matching lines @@
     // 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() {
     if (LoadConfig()) {
-      context_->network_message_loop()->PostTask(
+      context_->network_task_runner()->PostTask(
           FROM_HERE,
           base::Bind(&HostProcess::CreateAuthenticatorFactory,
                      base::Unretained(this)));
     } else {
       LOG(ERROR) << "Invalid configuration.";
     }
   }
 
 #if defined(OS_WIN)
   class ConfigChangedDelegate : public base::files::FilePathWatcher::Delegate {
    public:
-    ConfigChangedDelegate(base::MessageLoopProxy* message_loop,
-                          const base::Closure& callback)
-        : message_loop_(message_loop),
+    ConfigChangedDelegate(
+        scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+        const base::Closure& callback)
+        : task_runner_(task_runner),
           callback_(callback) {
     }
 
     void OnFilePathChanged(const FilePath& path) OVERRIDE {
-      message_loop_->PostTask(FROM_HERE, callback_);
+      task_runner_->PostTask(FROM_HERE, callback_);
     }
 
     void OnFilePathError(const FilePath& path) OVERRIDE {
     }
 
    private:
-    scoped_refptr<base::MessageLoopProxy> message_loop_;
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     base::Closure callback_;
 
     DISALLOW_COPY_AND_ASSIGN(ConfigChangedDelegate);
   };
 #endif  // defined(OS_WIN)
 
   void ListenForConfigChanges() {
 #if defined(OS_MACOSX)
     remoting::RegisterHupSignalHandler(
         base::Bind(&HostProcess::ConfigUpdatedDelayed, base::Unretained(this)));
@@ skipping 22 matching lines @@
       return kInvalidHostConfigurationExitCode;
     }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset(new HostUserInterface(context_.get()));
 #endif
 
     StartWatchingNatPolicy();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
-    context_->file_message_loop()->PostTask(
+    context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
     base::WaitableEvent done_event(true, false);
     nat_policy_->StopWatching(&done_event);
     done_event.Wait();
     nat_policy_.reset();
 
     return exit_code_;
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
     LOG(ERROR) << "Host ID not found.";
     Shutdown(kInvalidHostIdExitCode);
   }
 
  private:
   void StartWatchingNatPolicy() {
     nat_policy_.reset(
-        policy_hack::NatPolicy::Create(context_->file_message_loop()));
+        policy_hack::NatPolicy::Create(context_->file_task_runner()));
     nat_policy_->StartWatching(
         base::Bind(&HostProcess::OnNatPolicyUpdate, base::Unretained(this)));
   }
 
   // Read Host config from disk, returning true if successful.
   bool LoadConfig() {
     JsonHostConfig host_config(host_config_path_);
     JsonHostConfig auth_config(auth_config_path_);
 
     FilePath failed_path;
@@ skipping 50 matching lines @@
                                       &xmpp_auth_service_)) {
       // For the me2me host, we default to ClientLogin token for chromiumsync
       // because earlier versions of the host had no HTTP stack with which to
       // request an OAuth2 access token.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
     return true;
   }
 
   void OnNatPolicyUpdate(bool nat_traversal_enabled) {
-    if (!context_->network_message_loop()->BelongsToCurrentThread()) {
-      context_->network_message_loop()->PostTask(FROM_HERE, base::Bind(
+    if (!context_->network_task_runner()->BelongsToCurrentThread()) {
+      context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
           &HostProcess::OnNatPolicyUpdate, base::Unretained(this),
           nat_traversal_enabled));
       return;
     }
 
     bool policy_changed = allow_nat_traversal_ != nat_traversal_enabled;
     allow_nat_traversal_ = nat_traversal_enabled;
 
     if (host_) {
       // Restart the host if the policy has changed while the host was
       // online.
       if (policy_changed)
         RestartHost();
     } else {
       // Just start the host otherwise.
       StartHost();
     }
   }
 
   void StartHost() {
-    DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     DCHECK(!host_);
 
     if (!signal_strategy_.get()) {
       signal_strategy_.reset(
           new XmppSignalStrategy(context_->jingle_thread(), xmpp_login_,
                                  xmpp_auth_token_, xmpp_auth_service_));
 
       signaling_connector_.reset(new SignalingConnector(
           signal_strategy_.get(),
           base::Bind(&HostProcess::OnAuthFailed, base::Unretained(this))));
@@ skipping 72 matching lines @@
 
   // Invoked when the user uses the Disconnect windows to terminate
   // the sessions.
   void OnDisconnectRequested() {
     DCHECK(message_loop_.message_loop_proxy()->BelongsToCurrentThread());
 
     host_->DisconnectAllClients();
   }
 
   void RestartHost() {
-    DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (restarting_ || shutting_down_)
       return;
 
     restarting_ = true;
     host_->Shutdown(base::Bind(
         &HostProcess::RestartOnHostShutdown, base::Unretained(this)));
   }
 
   void RestartOnHostShutdown() {
-    DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (shutting_down_)
       return;
 
     restarting_ = false;
     host_ = NULL;
     log_to_server_.reset();
     host_event_logger_.reset();
     heartbeat_sender_.reset();
 
     StartHost();
   }
 
   void Shutdown(int exit_code) {
-    DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (shutting_down_)
       return;
 
     shutting_down_ = true;
     exit_code_ = exit_code;
     host_->Shutdown(base::Bind(
         &HostProcess::OnShutdownFinished, base::Unretained(this)));
   }
 
   void OnShutdownFinished() {
-    DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     // Destroy networking objects while we are on the network thread.
     host_ = NULL;
     host_event_logger_.reset();
     log_to_server_.reset();
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
 
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
@@ skipping 121 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)