Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

remoting/host/plugin/host_script_object.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.
 
 #include "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 67 matching lines @@
 
 HostNPScriptObject::HostNPScriptObject(
     NPP plugin,
     NPObject* parent,
     PluginMessageLoopProxy::Delegate* plugin_thread_delegate)
     : plugin_(plugin),
       parent_(parent),
       am_currently_logging_(false),
       state_(kDisconnected),
       np_thread_id_(base::PlatformThread::CurrentId()),
-      plugin_message_loop_proxy_(
+      plugin_task_runner_(
           new PluginMessageLoopProxy(plugin_thread_delegate)),
       failed_login_attempts_(0),
       disconnected_event_(true, false),
       nat_traversal_enabled_(false),
       policy_received_(false),
       daemon_controller_(DaemonController::Create()),
       worker_thread_("RemotingHostPlugin") {
   worker_thread_.Start();
 }
 
 HostNPScriptObject::~HostNPScriptObject() {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   HostLogHandler::UnregisterLoggingScriptObject(this);
 
-  plugin_message_loop_proxy_->Detach();
+  plugin_task_runner_->Detach();
 
   // Stop listening for policy updates.
   if (nat_policy_.get()) {
     base::WaitableEvent nat_policy_stopped_(true, false);
     nat_policy_->StopWatching(&nat_policy_stopped_);
     nat_policy_stopped_.Wait();
     nat_policy_.reset();
   }
 
   if (host_context_.get()) {
@@ skipping 13 matching lines @@
     it2me_host_user_interface_.reset();
 
     // Stops all threads.
     host_context_.reset();
   }
 
   worker_thread_.Stop();
 }
 
 bool HostNPScriptObject::Init() {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   VLOG(2) << "Init";
 
-  host_context_.reset(new ChromotingHostContext(plugin_message_loop_proxy_));
+  host_context_.reset(new ChromotingHostContext(plugin_task_runner_));
   if (!host_context_->Start()) {
     host_context_.reset();
     return false;
   }
 
   nat_policy_.reset(
-      policy_hack::NatPolicy::Create(host_context_->network_message_loop()));
+      policy_hack::NatPolicy::Create(host_context_->network_task_runner()));
   nat_policy_->StartWatching(
       base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                  base::Unretained(this)));
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
   VLOG(2) << "HasMethod " << method_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (method_name == kFuncNameConnect ||
@@ skipping 222 matching lines @@
     kFuncNameStartDaemon,
     kFuncNameStopDaemon
   };
   for (size_t i = 0; i < arraysize(entries); ++i) {
     values->push_back(entries[i]);
   }
   return true;
 }
 
 void HostNPScriptObject::OnAccessDenied(const std::string& jid) {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
     DisconnectInternal();
   }
 }
 
 void HostNPScriptObject::OnClientAuthenticated(const std::string& jid) {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   if (state_ == kDisconnecting) {
     // Ignore the new connection if we are disconnecting.
     return;
   }
 
   client_username_ = jid;
   size_t pos = client_username_.find('/');
   if (pos != std::string::npos)
     client_username_.replace(pos, std::string::npos, "");
   LOG(INFO) << "Client " << client_username_ << " connected.";
   SetState(kConnected);
 }
 
 void HostNPScriptObject::OnClientDisconnected(const std::string& jid) {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
   client_username_.clear();
   DisconnectInternal();
 }
 
 void HostNPScriptObject::OnShutdown() {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   register_request_.reset();
   log_to_server_.reset();
   signal_strategy_.reset();
   host_->RemoveStatusObserver(this);
   host_ = NULL;
 
   if (state_ != kDisconnected) {
     SetState(kDisconnected);
   }
 }
 
 // string uid, string auth_token
 bool HostNPScriptObject::Connect(const NPVariant* args,
                                  uint32_t arg_count,
                                  NPVariant* result) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   LOG(INFO) << "Connecting...";
 
   if (arg_count != 2) {
     SetException("connect: bad number of arguments");
     return false;
   }
 
   if (state_ != kDisconnected) {
     SetException("connect: can be called only when disconnected");
@@ skipping 21 matching lines @@
       new It2MeHostUserInterface(host_context_.get()));
 
   ReadPolicyAndConnect(uid, auth_token, auth_service);
 
   return true;
 }
 
 void HostNPScriptObject::ReadPolicyAndConnect(const std::string& uid,
                                               const std::string& auth_token,
                                               const std::string& auth_service) {
-  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
-    host_context_->network_message_loop()->PostTask(
+  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+    host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::ReadPolicyAndConnect, base::Unretained(this),
             uid, auth_token, auth_service));
     return;
   }
 
   SetState(kStarting);
 
   // Only proceed to FinishConnect() if at least one policy update has been
   // received.
   if (policy_received_) {
     FinishConnectMainThread(uid, auth_token, auth_service);
   } else {
     // Otherwise, create the policy watcher, and thunk the connect.
     pending_connect_ =
         base::Bind(&HostNPScriptObject::FinishConnectMainThread,
                    base::Unretained(this), uid, auth_token, auth_service);
   }
 }
 
 void HostNPScriptObject::FinishConnectMainThread(
     const std::string& uid,
     const std::string& auth_token,
     const std::string& auth_service) {
-  if (host_context_->main_message_loop() != MessageLoop::current()) {
-    host_context_->main_message_loop()->PostTask(FROM_HERE, base::Bind(
+  if (!host_context_->capture_task_runner()->BelongsToCurrentThread()) {
+    host_context_->capture_task_runner()->PostTask(FROM_HERE, base::Bind(
         &HostNPScriptObject::FinishConnectMainThread, base::Unretained(this),
         uid, auth_token, auth_service));
     return;
   }
 
-  // DesktopEnvironment must be initialized on the main thread.
+  // DesktopEnvironment must be initialized on the capture thread.
   //
   // TODO(sergeyu): Fix DesktopEnvironment so that it can be created
   // on either the UI or the network thread so that we can avoid
   // jumping to the main thread here.
   desktop_environment_ = DesktopEnvironment::Create(host_context_.get());
 
   FinishConnectNetworkThread(uid, auth_token, auth_service);
 }
 
 void HostNPScriptObject::FinishConnectNetworkThread(
     const std::string& uid,
     const std::string& auth_token,
     const std::string& auth_service) {
-  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
-    host_context_->network_message_loop()->PostTask(FROM_HERE, base::Bind(
+  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+    host_context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
         &HostNPScriptObject::FinishConnectNetworkThread, base::Unretained(this),
         uid, auth_token, auth_service));
     return;
   }
 
   if (state_ != kStarting) {
     // Host has been stopped while we were fetching policy.
     return;
   }
 
@@ skipping 48 matching lines @@
   signal_strategy_->Connect();
   host_->Start();
 
   SetState(kRequestedAccessCode);
   return;
 }
 
 bool HostNPScriptObject::Disconnect(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   if (arg_count != 0) {
     SetException("disconnect: bad number of arguments");
     return false;
   }
 
   DisconnectInternal();
 
   return true;
 }
 
 bool HostNPScriptObject::Localize(const NPVariant* args,
                                   uint32_t arg_count,
                                   NPVariant* result) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   if (arg_count != 1) {
     SetException("localize: bad number of arguments");
     return false;
   }
 
   if (NPVARIANT_IS_OBJECT(args[0])) {
     ScopedRefNPObject localize_func(NPVARIANT_TO_OBJECT(args[0]));
     LocalizeStrings(localize_func.get());
     return true;
   } else {
@@ skipping 218 matching lines @@
     return false;
   }
 
   daemon_controller_->Stop(
       base::Bind(&HostNPScriptObject::InvokeAsyncResultCallback,
                  base::Unretained(this), callback_obj));
   return true;
 }
 
 void HostNPScriptObject::DisconnectInternal() {
-  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
-    host_context_->network_message_loop()->PostTask(
+  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+    host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::DisconnectInternal,
                               base::Unretained(this)));
     return;
   }
 
   switch (state_) {
     case kDisconnected:
       disconnected_event_.Signal();
       return;
 
     case kStarting:
       SetState(kDisconnecting);
       SetState(kDisconnected);
       disconnected_event_.Signal();
       return;
 
     case kDisconnecting:
       return;
 
     default:
       DCHECK(host_);
       SetState(kDisconnecting);
 
       // ChromotingHost::Shutdown() may destroy SignalStrategy
       // synchronously, bug SignalStrategy::Listener handlers are not
       // allowed to destroy SignalStrategy, so post task to call
       // Shutdown() later.
-      host_context_->network_message_loop()->PostTask(
+      host_context_->network_task_runner()->PostTask(
           FROM_HERE, base::Bind(
               &ChromotingHost::Shutdown, host_,
               base::Bind(&HostNPScriptObject::OnShutdownFinished,
                          base::Unretained(this))));
   }
 }
 
 void HostNPScriptObject::OnShutdownFinished() {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   disconnected_event_.Signal();
 }
 
 void HostNPScriptObject::OnNatPolicyUpdate(bool nat_traversal_enabled) {
-  if (!host_context_->network_message_loop()->BelongsToCurrentThread()) {
-    host_context_->network_message_loop()->PostTask(
+  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+    host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostNPScriptObject::OnNatPolicyUpdate,
                    base::Unretained(this), nat_traversal_enabled));
     return;
   }
 
   VLOG(2) << "OnNatPolicyUpdate: " << nat_traversal_enabled;
 
   // When transitioning from enabled to disabled, force disconnect any
   // existing session.
@@ skipping 12 matching lines @@
   if (!pending_connect_.is_null()) {
     pending_connect_.Run();
     pending_connect_.Reset();
   }
 }
 
 void HostNPScriptObject::OnReceivedSupportID(
     bool success,
     const std::string& support_id,
     const base::TimeDelta& lifetime) {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   if (!success) {
     SetState(kError);
     DisconnectInternal();
     return;
   }
 
   std::string host_secret = GenerateSupportHostSecret();
   std::string access_code = support_id + host_secret;
   scoped_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           host_key_pair_.GenerateCertificate(), *host_key_pair_.private_key(),
           access_code));
   host_->SetAuthenticatorFactory(factory.Pass());
 
   {
     base::AutoLock lock(access_code_lock_);
     access_code_ = access_code;
     access_code_lifetime_ = lifetime;
   }
 
   SetState(kReceivedAccessCode);
 }
 
 void HostNPScriptObject::SetState(State state) {
-  DCHECK(host_context_->network_message_loop()->BelongsToCurrentThread());
+  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
   switch (state_) {
     case kDisconnected:
       DCHECK(state == kStarting ||
              state == kError) << state;
       break;
     case kStarting:
       DCHECK(state == kRequestedAccessCode ||
              state == kDisconnecting ||
              state == kError) << state;
       break;
@@ skipping 17 matching lines @@
       break;
     case kError:
       DCHECK(state == kDisconnecting) << state;
       break;
   };
   state_ = state;
   NotifyStateChanged(state);
 }
 
 void HostNPScriptObject::NotifyStateChanged(State state) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::NotifyStateChanged,
                               base::Unretained(this), state));
     return;
   }
   if (on_state_changed_func_.get()) {
     VLOG(2) << "Calling state changed " << state;
     NPVariant state_var;
     INT32_TO_NPVARIANT(state, state_var);
     bool is_good = InvokeAndIgnoreResult(on_state_changed_func_.get(),
                                          &state_var, 1);
     LOG_IF(ERROR, !is_good) << "OnStateChanged failed";
   }
 }
 void HostNPScriptObject::PostLogDebugInfo(const std::string& message) {
-  if (plugin_message_loop_proxy_->BelongsToCurrentThread()) {
+  if (plugin_task_runner_->BelongsToCurrentThread()) {
     // Make sure we're not currently processing a log message.
     // We only need to check this if we're on the plugin thread.
     if (am_currently_logging_)
       return;
   }
 
   // Always post (even if we're already on the correct thread) so that debug
   // log messages are shown in the correct order.
-  plugin_message_loop_proxy_->PostTask(
+  plugin_task_runner_->PostTask(
       FROM_HERE, base::Bind(&HostNPScriptObject::LogDebugInfo,
                             base::Unretained(this), message));
 }
 
 void HostNPScriptObject::SetWindow(NPWindow* np_window) {
   daemon_controller_->SetWindow(np_window->window);
 }
 
 void HostNPScriptObject::LocalizeStrings(NPObject* localize_func) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   UiStrings ui_strings;
   string16 direction;
   LocalizeString(localize_func, "@@bidi_dir", &direction);
   ui_strings.direction = UTF16ToUTF8(direction) == "rtl" ?
       remoting::UiStrings::RTL : remoting::UiStrings::LTR;
   LocalizeString(localize_func, /*i18n-content*/"PRODUCT_NAME",
                  &ui_strings.product_name);
   LocalizeString(localize_func, /*i18n-content*/"DISCONNECT_OTHER_BUTTON",
                  &ui_strings.disconnect_button_text);
@@ skipping 34 matching lines @@
   g_npnetscape_funcs->releasevariantvalue(&np_result);
   if (translation.empty()) {
     LOG(ERROR) << "Missing translation for " << tag;
     return false;
   }
   *result = UTF8ToUTF16(translation);
   return true;
 }
 
 void HostNPScriptObject::UpdateWebappNatPolicy(bool nat_traversal_enabled) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HostNPScriptObject::UpdateWebappNatPolicy,
                               base::Unretained(this), nat_traversal_enabled));
     return;
   }
   if (on_nat_traversal_policy_changed_func_.get()) {
     NPVariant policy;
     BOOLEAN_TO_NPVARIANT(nat_traversal_enabled, policy);
     InvokeAndIgnoreResult(on_nat_traversal_policy_changed_func_.get(),
                           &policy, 1);
   }
 }
 
 void HostNPScriptObject::DoGenerateKeyPair(const ScopedRefNPObject& callback) {
   HostKeyPair key_pair;
   key_pair.Generate();
   InvokeGenerateKeyPairCallback(callback, key_pair.GetAsString(),
                                 key_pair.GetPublicKey());
 }
 
 void HostNPScriptObject::InvokeGenerateKeyPairCallback(
     const ScopedRefNPObject& callback,
     const std::string& private_key,
     const std::string& public_key) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGenerateKeyPairCallback,
             base::Unretained(this), callback, private_key, public_key));
     return;
   }
 
   NPVariant params[2];
   params[0] = NPVariantFromString(private_key);
   params[1] = NPVariantFromString(public_key);
   InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
   g_npnetscape_funcs->releasevariantvalue(&(params[0]));
   g_npnetscape_funcs->releasevariantvalue(&(params[1]));
 }
 
 void HostNPScriptObject::InvokeAsyncResultCallback(
     const ScopedRefNPObject& callback,
     DaemonController::AsyncResult result) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeAsyncResultCallback,
             base::Unretained(this), callback, result));
     return;
   }
 
   NPVariant result_var;
   INT32_TO_NPVARIANT(static_cast<int32>(result), result_var);
   InvokeAndIgnoreResult(callback.get(), &result_var, 1);
   g_npnetscape_funcs->releasevariantvalue(&result_var);
 }
 
 void HostNPScriptObject::InvokeGetDaemonConfigCallback(
     const ScopedRefNPObject& callback,
     scoped_ptr<base::DictionaryValue> config) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGetDaemonConfigCallback,
             base::Unretained(this), callback, base::Passed(&config)));
     return;
   }
 
   // There is no easy way to create a dictionary from an NPAPI plugin
   // so we have to serialize the dictionary to pass it to JavaScript.
   std::string config_str;
   if (config.get())
     base::JSONWriter::Write(config.get(), &config_str);
 
   NPVariant config_val = NPVariantFromString(config_str);
   InvokeAndIgnoreResult(callback.get(), &config_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&config_val);
 }
 
 void HostNPScriptObject::InvokeGetDaemonVersionCallback(
     const ScopedRefNPObject& callback, const std::string& version) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGetDaemonVersionCallback,
             base::Unretained(this), callback, version));
     return;
   }
 
   NPVariant version_val = NPVariantFromString(version);
   InvokeAndIgnoreResult(callback.get(), &version_val, 1);
   g_npnetscape_funcs->releasevariantvalue(&version_val);
 }
 
 void HostNPScriptObject::InvokeGetUsageStatsConsentCallback(
     const ScopedRefNPObject& callback,
     bool supported,
     bool allowed,
     bool set_by_policy) {
-  if (!plugin_message_loop_proxy_->BelongsToCurrentThread()) {
-    plugin_message_loop_proxy_->PostTask(
+  if (!plugin_task_runner_->BelongsToCurrentThread()) {
+    plugin_task_runner_->PostTask(
         FROM_HERE, base::Bind(
             &HostNPScriptObject::InvokeGetUsageStatsConsentCallback,
             base::Unretained(this), callback, supported, allowed,
             set_by_policy));
     return;
   }
 
   NPVariant params[3];
   BOOLEAN_TO_NPVARIANT(supported, params[0]);
   BOOLEAN_TO_NPVARIANT(allowed, params[1]);
   BOOLEAN_TO_NPVARIANT(set_by_policy, params[2]);
   InvokeAndIgnoreResult(callback.get(), params, arraysize(params));
   g_npnetscape_funcs->releasevariantvalue(&(params[0]));
   g_npnetscape_funcs->releasevariantvalue(&(params[1]));
   g_npnetscape_funcs->releasevariantvalue(&(params[2]));
 }
 
 void HostNPScriptObject::LogDebugInfo(const std::string& message) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   if (log_debug_info_func_.get()) {
     am_currently_logging_ = true;
     NPVariant log_message;
     STRINGZ_TO_NPVARIANT(message.c_str(), log_message);
     bool is_good = InvokeAndIgnoreResult(log_debug_info_func_.get(),
                                          &log_message, 1);
     if (!is_good) {
       LOG(ERROR) << "ERROR - LogDebugInfo failed\n";
     }
     am_currently_logging_ = false;
   }
 }
 
 bool HostNPScriptObject::InvokeAndIgnoreResult(NPObject* func,
                                                const NPVariant* args,
                                                uint32_t arg_count) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    arg_count, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
-  DCHECK(plugin_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting