Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

remoting/host/simple_host_process.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 is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 135 matching lines @@
       return 1;
     }
     if (!config.GetString(kXmppAuthServiceConfigPath, &xmpp_auth_service_)) {
       // For the simple host, we assume we always use the ClientLogin token for
       // chromiumsync because we do not have an HTTP stack with which we can
       // easily request an OAuth2 access token even if we had a RefreshToken for
       // the account.
       xmpp_auth_service_ = kChromotingTokenDefaultServiceName;
     }
 
-    context_.network_message_loop()->PostTask(FROM_HERE, base::Bind(
+    context_.network_task_runner()->PostTask(FROM_HERE, base::Bind(
         &SimpleHost::StartHost, base::Unretained(this)));
 
     message_loop_.MessageLoop::Run();
 
     return exit_code_;
   }
 
   void set_config_path(const FilePath& config_path) {
     config_path_ = config_path;
   }
@@ skipping 52 matching lines @@
     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(&SimpleHost::OnAuthFailed, base::Unretained(this))));
 
     if (fake_) {
       scoped_ptr<Capturer> capturer(new CapturerFake());
       scoped_ptr<EventExecutor> event_executor = EventExecutor::Create(
-          context_.desktop_message_loop()->message_loop_proxy(),
-          context_.ui_message_loop(), capturer.get());
+          context_.desktop_task_runner(),
+          context_.ui_task_runner(), capturer.get());
       desktop_environment_ = DesktopEnvironment::CreateFake(
           &context_, capturer.Pass(), event_executor.Pass());
     } else {
       desktop_environment_ = DesktopEnvironment::Create(&context_);
     }
 
     host_ = new ChromotingHost(
         &context_, signal_strategy_.get(), desktop_environment_.get(),
         CreateHostSessionManager(network_settings_,
                                  context_.url_request_context_getter()));
@@ skipping 32 matching lines @@
               host_secret_hash_));
       host_->SetAuthenticatorFactory(factory.Pass());
     }
   }
 
   void OnAuthFailed() {
     Shutdown(kInvalidOauthCredentialsExitCode);
   }
 
   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(
         &SimpleHost::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;
     log_to_server_.reset();
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
 
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
@@ skipping 121 matching lines @@
         max_port < 0 || max_port > 65535) {
       LOG(ERROR) << "Invalid max-port value: " << max_port
                  << ". Expected integer in range [0, 65535].";
       return 1;
     }
     simple_host.network_settings()->max_port = max_port;
   }
 
   return simple_host.Run();
 }