Remote assistance on Chrome OS Part IV - It2MeHost

remoting/host/it2me/it2me_host.cc

Index: remoting/host/it2me/it2me_host.cc
diff --git a/remoting/host/it2me/it2me_host.cc b/remoting/host/it2me/it2me_host.cc
index b9a17f8c9431b159fddbcd15a586eb438b315995..7adebc7cd7f9efa142a612d1720fcf76f0310f40 100644
--- a/remoting/host/it2me/it2me_host.cc
+++ b/remoting/host/it2me/it2me_host.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "net/socket/client_socket_factory.h"
 #include "remoting/base/auto_thread.h"
@@ -43,6 +42,7 @@ It2MeHost::It2MeHost(
     const std::string& directory_bot_jid)
   : host_context_(host_context),
     task_runner_(task_runner),
+    network_task_runner_(host_context_->network_task_runner()),
     observer_(observer),
     xmpp_server_config_(xmpp_server_config),
     directory_bot_jid_(directory_bot_jid),
@@ -62,25 +62,25 @@ void It2MeHost::Connect() {
   }
 
   desktop_environment_factory_.reset(new It2MeDesktopEnvironmentFactory(
-      host_context_->network_task_runner(),
+      network_task_runner_,
       host_context_->input_task_runner(),
       host_context_->ui_task_runner()));
 
   // Start monitoring configured policies.
   policy_watcher_.reset(
-      policy_hack::PolicyWatcher::Create(host_context_->network_task_runner()));
+      policy_hack::PolicyWatcher::Create(host_context_, network_task_runner_));
   policy_watcher_->StartWatching(
       base::Bind(&It2MeHost::OnPolicyUpdate, this));
 
   // Switch to the network thread to start the actual connection.
-  host_context_->network_task_runner()->PostTask(
+  network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::ReadPolicyAndConnect, this));
 }
 
 void It2MeHost::Disconnect() {
-  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+  if (!network_task_runner_->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    host_context_->network_task_runner()->PostTask(
+    network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::Disconnect, this));
     return;
   }
@@ -111,16 +111,16 @@ void It2MeHost::Disconnect() {
       // Deleting the host destroys SignalStrategy synchronously, but
       // SignalStrategy::Listener handlers are not allowed to destroy
       // SignalStrategy, so post task to destroy the host later.
-      host_context_->network_task_runner()->PostTask(
+      network_task_runner_->PostTask(
           FROM_HERE, base::Bind(&It2MeHost::ShutdownOnNetworkThread, this));
       return;
   }
 }
 
 void It2MeHost::RequestNatPolicy() {
-  if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
+  if (!network_task_runner_->BelongsToCurrentThread()) {
     DCHECK(task_runner_->BelongsToCurrentThread());
-    host_context_->network_task_runner()->PostTask(
+    network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&It2MeHost::RequestNatPolicy, this));
     return;
   }
@@ -130,7 +130,7 @@ void It2MeHost::RequestNatPolicy() {
 }
 
 void It2MeHost::ReadPolicyAndConnect() {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   SetState(kStarting);
 
@@ -146,7 +146,7 @@ void It2MeHost::ReadPolicyAndConnect() {
 }
 
 void It2MeHost::FinishConnect() {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (state_ != kStarting) {
     // Host has been stopped while we were fetching policy.
@@ -203,7 +203,7 @@ void It2MeHost::FinishConnect() {
       host_context_->input_task_runner(),
       host_context_->video_capture_task_runner(),
       host_context_->video_encode_task_runner(),
-      host_context_->network_task_runner(),
+      network_task_runner_,
       host_context_->ui_task_runner()));
   host_->AddStatusObserver(this);
   host_status_logger_.reset(
@@ -231,7 +231,7 @@ void It2MeHost::FinishConnect() {
 }
 
 void It2MeHost::ShutdownOnNetworkThread() {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kDisconnecting || state_ == kDisconnected);
 
   if (state_ == kDisconnecting) {
@@ -245,27 +245,30 @@ void It2MeHost::ShutdownOnNetworkThread() {
     SetState(kDisconnected);
   }
 
-  host_context_->ui_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&It2MeHost::ShutdownOnUiThread, this));
+  task_runner_->PostTask(FROM_HERE,

[Jamie, 2014/10/14 01:18:42]

Why has this changed?

[kelvinp, 2014/10/15 23:03:10]

As per wez, comment, we are trying to take reference on the task_runner of the
ChromotingHostContext instead of holding on to the host.

+                         base::Bind(&It2MeHost::ShutdownOnUiThread, this));
 }
 
 void It2MeHost::ShutdownOnUiThread() {
-  DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
+  DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Destroy the DesktopEnvironmentFactory, to free thread references.
   desktop_environment_factory_.reset();
 
   // Stop listening for policy updates.
   if (policy_watcher_.get()) {
-    base::WaitableEvent policy_watcher_stopped_(true, false);
-    policy_watcher_->StopWatching(&policy_watcher_stopped_);
-    policy_watcher_stopped_.Wait();
-    policy_watcher_.reset();
+    policy_watcher_->StopWatching(
+        base::Bind(&It2MeHost::OnPolicyWatcherShutdown, this));
+    return;
   }
 }
 
+void It2MeHost::OnPolicyWatcherShutdown() {
+  policy_watcher_.reset();
+}
+
 void It2MeHost::OnAccessDenied(const std::string& jid) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
@@ -274,7 +277,7 @@ void It2MeHost::OnAccessDenied(const std::string& jid) {
 }
 
 void It2MeHost::OnClientAuthenticated(const std::string& jid) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (state_ == kDisconnecting) {
     // Ignore the new connection if we are disconnecting.
@@ -305,13 +308,13 @@ void It2MeHost::OnClientAuthenticated(const std::string& jid) {
 }
 
 void It2MeHost::OnClientDisconnected(const std::string& jid) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   Disconnect();
 }
 
 void It2MeHost::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   bool nat_policy;
   if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
@@ -333,7 +336,7 @@ void It2MeHost::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
 }
 
 void It2MeHost::UpdateNatPolicy(bool nat_traversal_enabled) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateNatPolicy: " << nat_traversal_enabled;
 
@@ -352,7 +355,7 @@ void It2MeHost::UpdateNatPolicy(bool nat_traversal_enabled) {
 }
 
 void It2MeHost::UpdateHostDomainPolicy(const std::string& host_domain) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   VLOG(2) << "UpdateHostDomainPolicy: " << host_domain;
 
@@ -371,7 +374,7 @@ It2MeHost::~It2MeHost() {
 }
 
 void It2MeHost::SetState(It2MeHostState state) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   switch (state_) {
     case kDisconnected:
@@ -427,7 +430,7 @@ void It2MeHost::OnReceivedSupportID(
     bool success,
     const std::string& support_id,
     const base::TimeDelta& lifetime) {
-  DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
+  DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!success) {
     SetState(kError);