It2Me Host cleanup - Remove task_runner_

remoting/host/it2me/it2me_host.cc

 // Copyright 2013 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/it2me/it2me_host.h"
 
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 46 matching lines @@
 }  // namespace
 
 It2MeHost::It2MeHost(
     std::unique_ptr<ChromotingHostContext> host_context,
     std::unique_ptr<PolicyWatcher> policy_watcher,
     std::unique_ptr<It2MeConfirmationDialog> confirmation_dialog,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid)
     : host_context_(std::move(host_context)),
-      task_runner_(host_context_->ui_task_runner()),
       observer_(observer),
       xmpp_server_config_(xmpp_server_config),
       directory_bot_jid_(directory_bot_jid),
       policy_watcher_(std::move(policy_watcher)),
       confirmation_dialog_(std::move(confirmation_dialog)) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
 }
 
 It2MeHost::~It2MeHost() {
   // Check that resources that need to be torn down on the UI thread are gone.
   DCHECK(!desktop_environment_factory_.get());
   DCHECK(!policy_watcher_.get());
 }
 
 void It2MeHost::Connect() {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::Connect, this));
     return;
   }
 
   desktop_environment_factory_.reset(new It2MeDesktopEnvironmentFactory(
       host_context_->network_task_runner(),
       host_context_->video_capture_task_runner(),
       host_context_->input_task_runner(), host_context_->ui_task_runner()));
 
   // Start monitoring configured policies.
   policy_watcher_->StartWatching(
       base::Bind(&It2MeHost::OnPolicyUpdate, this),
       base::Bind(&It2MeHost::OnPolicyError, this));
 
   // Switch to the network thread to start the actual connection.
   host_context_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::ReadPolicyAndConnect, this));
 }
 
 void It2MeHost::Disconnect() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
   host_context_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::DisconnectOnNetworkThread, this));
 }
 
 void It2MeHost::DisconnectOnNetworkThread() {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   // Disconnect() may be called even when after the host been already stopped.
   // Ignore repeated calls.
   if (state_ == kDisconnected) {
@@ skipping 16 matching lines @@
   host_context_->ui_task_runner()->DeleteSoon(
       FROM_HERE, desktop_environment_factory_.release());
   host_context_->ui_task_runner()->DeleteSoon(FROM_HERE,
                                               policy_watcher_.release());
 
   SetState(kDisconnected, "");
 }
 
 void It2MeHost::RequestNatPolicy() {
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
-    DCHECK(task_runner_->BelongsToCurrentThread());
+    DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
     host_context_->network_task_runner()->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::RequestNatPolicy, this));
     return;
   }
 
   if (policy_received_)
     UpdateNatPolicy(nat_traversal_enabled_);
 }
 
 void It2MeHost::ReadPolicyAndConnect() {
@@ skipping 121 matching lines @@
 
   std::string client_username;
   if (!SplitJidResource(jid, &client_username, /*resource=*/nullptr)) {
     LOG(WARNING) << "Incorrectly formatted JID received: " << jid;
     client_username = jid;
   }
 
   HOST_LOG << "Client " << client_username << " connected.";
 
   // Pass the client user name to the script object before changing state.
-  task_runner_->PostTask(
+  host_context_->ui_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnClientAuthenticated,
                             observer_, client_username));
 
   SetState(kConnected, "");
 }
 
 void It2MeHost::OnClientDisconnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   DisconnectOnNetworkThread();
@@ skipping 57 matching lines @@
 
   // When transitioning from enabled to disabled, force disconnect any
   // existing session.
   if (nat_traversal_enabled_ && !nat_traversal_enabled && IsConnected()) {
     DisconnectOnNetworkThread();
   }
 
   nat_traversal_enabled_ = nat_traversal_enabled;
 
   // Notify the web-app of the policy setting.
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::Observer::OnNatPolicyChanged,
-                            observer_, nat_traversal_enabled_));
+  host_context_->ui_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&It2MeHost::Observer::OnNatPolicyChanged, observer_,
+                            nat_traversal_enabled_));
 }
 
 void It2MeHost::UpdateHostDomainPolicy(const std::string& host_domain) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateHostDomainPolicy: " << host_domain;
 
   // When setting a host domain policy, force disconnect any existing session.
   if (!host_domain.empty() && IsConnected()) {
     DisconnectOnNetworkThread();
@@ skipping 48 matching lines @@
       DCHECK(state == kDisconnected) << state;
       break;
     case kInvalidDomainError:
       DCHECK(state == kDisconnected) << state;
       break;
   };
 
   state_ = state;
 
   // Post a state-change notification to the web-app.
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::Observer::OnStateChanged,
-                            observer_, state, error_message));
+  host_context_->ui_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&It2MeHost::Observer::OnStateChanged, observer_,
+                            state, error_message));
 }
 
 bool It2MeHost::IsConnected() const {
   return state_ == kRequestedAccessCode || state_ == kReceivedAccessCode ||
       state_ == kConnected;
 }
 
 void It2MeHost::OnReceivedSupportID(
     const std::string& support_id,
     const base::TimeDelta& lifetime,
@@ skipping 21 matching lines @@
   }
 
   std::unique_ptr<protocol::AuthenticatorFactory> factory(
       new protocol::It2MeHostAuthenticatorFactory(
           local_certificate, host_key_pair_, access_code_hash,
           base::Bind(&It2MeHost::ValidateConnectionDetails,
                      base::Unretained(this))));
   host_->SetAuthenticatorFactory(std::move(factory));
 
   // Pass the Access Code to the script object before changing state.
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::Observer::OnStoreAccessCode,
-                            observer_, access_code, lifetime));
+  host_context_->ui_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&It2MeHost::Observer::OnStoreAccessCode, observer_,
+                            access_code, lifetime));
 
   SetState(kReceivedAccessCode, "");
 }
 
 void It2MeHost::ValidateConnectionDetails(
     const std::string& remote_jid,
     const protocol::ValidatingAuthenticator::ResultCallback& result_callback) {
   // First ensure the JID we received is valid.
   std::string client_username;
   if (!SplitJidResource(remote_jid, &client_username, /*resource=*/nullptr)) {
@@ skipping 59 matching lines @@
   DCHECK(context->ui_task_runner()->BelongsToCurrentThread());
 
   std::unique_ptr<PolicyWatcher> policy_watcher =
       PolicyWatcher::Create(policy_service, context->file_task_runner());
   return new It2MeHost(std::move(context), std::move(policy_watcher),
                        It2MeConfirmationDialog::Create(), observer,
                        xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting