Always run PolicyWatcher on UI thread in It2Me host.

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 "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/threading/platform_thread.h"
 #include "net/socket/client_socket_factory.h"
@@ skipping 280 matching lines @@
       FROM_HERE, base::Bind(&It2MeHost::ShutdownOnUiThread, this));
 }
 
 void It2MeHost::ShutdownOnUiThread() {
   DCHECK(host_context_->ui_task_runner()->BelongsToCurrentThread());
 
   // Destroy the DesktopEnvironmentFactory, to free thread references.
   desktop_environment_factory_.reset();
 
   // Stop listening for policy updates.
-  if (policy_watcher_.get()) {
-    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());
 
   ++failed_login_attempts_;
   if (failed_login_attempts_ == kMaxLoginAttempts) {
     Disconnect();
   }
@@ skipping 30 matching lines @@
   SetState(kConnected);
 }
 
 void It2MeHost::OnClientDisconnected(const std::string& jid) {
   DCHECK(host_context_->network_task_runner()->BelongsToCurrentThread());
 
   Disconnect();
 }
 
 void It2MeHost::OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
-  // The policy watcher runs on the |ui_task_runner| on ChromeOS and the
-  // |network_task_runner| on other platforms.
+  // The policy watcher runs on the |ui_task_runner|.
   if (!host_context_->network_task_runner()->BelongsToCurrentThread()) {
     host_context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&It2MeHost::OnPolicyUpdate, this, base::Passed(&policies)));
     return;
   }
 
   bool nat_policy;
   if (policies->GetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
                            &nat_policy)) {
@@ skipping 154 matching lines @@
   DCHECK(policy_service);
   DCHECK(!policy_service_) << "|policy_service| can only be set once.";
   policy_service_ = policy_service;
 }
 
 scoped_refptr<It2MeHost> It2MeHostFactory::CreateIt2MeHost(
     scoped_ptr<ChromotingHostContext> context,
     base::WeakPtr<It2MeHost::Observer> observer,
     const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
     const std::string& directory_bot_jid) {
+  DCHECK(context->ui_task_runner()->BelongsToCurrentThread());
+
   scoped_ptr<It2MeConfirmationDialogFactory> confirmation_dialog_factory(
       new It2MeConfirmationDialogFactory());
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher =
       policy_hack::PolicyWatcher::Create(policy_service_,
-                                         context->network_task_runner());
+                                         context->file_task_runner());
   return new It2MeHost(context.Pass(), policy_watcher.Pass(),
                        confirmation_dialog_factory.Pass(),
                        observer, xmpp_server_config, directory_bot_jid);
 }
 
 }  // namespace remoting