[Chromoting] Hook up host talkgadget policy checks.

remoting/host/remoting_me2me_host.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 file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 360 matching lines @@
     }
     if (policies->GetBoolean(policy_hack::PolicyWatcher::kNatPolicyName,
                              &bool_value)) {
       OnNatPolicyUpdate(bool_value);
     }
     if (policies->GetBoolean(
             policy_hack::PolicyWatcher::kHostRequireCurtainPolicyName,
             &bool_value)) {
       OnCurtainPolicyUpdate(bool_value);
     }
+    if (policies->GetString(
+            policy_hack::PolicyWatcher::kHostTalkGadgetPrefixPolicyName,
+            &string_value)) {
+      OnHostTalkGadgetPrefixPolicyUpdate(string_value);
+    }
   }
 
   void OnHostDomainPolicyUpdate(const std::string& host_domain) {
     if (!context_->network_task_runner()->BelongsToCurrentThread()) {
       context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
           &HostProcess::OnHostDomainPolicyUpdate, base::Unretained(this),
           host_domain));
       return;
     }
 
@@ skipping 47 matching lines @@
 
       host_->AddStatusObserver(&curtain_);
       curtain_.SetEnabled(true);
     } else {
       curtain_.SetEnabled(false);
       host_->RemoveStatusObserver(&curtain_);
     }
 #endif
   }
 
+  void OnHostTalkGadgetPrefixPolicyUpdate(
+      const std::string& talkgadget_prefix) {
+    if (!context_->network_task_runner()->BelongsToCurrentThread()) {
+      context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+          &HostProcess::OnHostTalkGadgetPrefixPolicyUpdate,
+          base::Unretained(this), talkgadget_prefix));
+      return;
+    }
+
+    LOG(INFO) << "Host talkgadget policy update: " << talkgadget_prefix;
+    if (talkgadget_prefix != talkgadget_prefix_) {
+      LOG(INFO) << "Restarting host due to changed talkgadget policy:";
+      LOG(INFO) << "  old talkgadget: " << talkgadget_prefix_;
+      LOG(INFO) << "  new talkgadget: " << talkgadget_prefix;
+      talkgadget_prefix_ = talkgadget_prefix;
+      RestartHost();
+    }
+  }
+
   void StartHost() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     DCHECK(!host_);
 
     if (shutting_down_)
       return;
 
     if (!signal_strategy_.get()) {
       signal_strategy_.reset(
           new XmppSignalStrategy(context_->url_request_context_getter(),
                                  xmpp_login_, xmpp_auth_token_,
                                  xmpp_auth_service_));
 
       signaling_connector_.reset(new SignalingConnector(
-          signal_strategy_.get(),
+          signal_strategy_.get(), context_.get(), talkgadget_prefix_,
           base::Bind(&HostProcess::OnAuthFailed, base::Unretained(this))));
 
       if (!oauth_refresh_token_.empty()) {
         OAuthClientInfo client_info = {
           kUnofficialOAuth2ClientId,
           kUnofficialOAuth2ClientSecret
         };
 
 #ifdef OFFICIAL_BUILD
         if (oauth_use_official_client_id_) {
           OAuthClientInfo official_client_info = {
             kOfficialOAuth2ClientId,
             kOfficialOAuth2ClientSecret
           };
 
           client_info = official_client_info;
         }
 #endif  // OFFICIAL_BUILD
 
         scoped_ptr<SignalingConnector::OAuthCredentials> oauth_credentials(
             new SignalingConnector::OAuthCredentials(
                 xmpp_login_, oauth_refresh_token_, client_info));
-        signaling_connector_->EnableOAuth(
-            oauth_credentials.Pass(),
-            context_->url_request_context_getter());
+        signaling_connector_->EnableOAuth(oauth_credentials.Pass());
       }
     }
 
     if (!desktop_environment_.get()) {
       desktop_environment_ =
           DesktopEnvironment::CreateForService(context_.get());
     }
 
     NetworkSettings network_settings(
         allow_nat_traversal_ ?
@@ skipping 56 matching lines @@
   }
 
   void RestartOnHostShutdown() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (shutting_down_)
       return;
 
     restarting_ = false;
     host_ = NULL;
-    log_to_server_.reset();
-    host_event_logger_.reset();
-    heartbeat_sender_.reset();
+    ResetHost();

[garykac, 2012/08/23 22:08:50]

Note that calling ResetHost here resets the SignalingConnector as well. This is
needed to reset the connection_attempts counter (or else updating the policy can
take up to 10 min before it will try to connect again).

 
     StartHost();
   }
 
   void Shutdown(int exit_code) {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     if (shutting_down_)
       return;
 
     shutting_down_ = true;
     exit_code_ = exit_code;
     if (host_) {
       host_->Shutdown(base::Bind(
           &HostProcess::OnShutdownFinished, base::Unretained(this)));
     } else {
       OnShutdownFinished();
     }
   }
 
   void OnShutdownFinished() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
     // Destroy networking objects while we are on the network thread.
     host_ = NULL;
+    ResetHost();
+
+    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
+  }
+
+  void ResetHost() {
+    DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+
     host_event_logger_.reset();
     log_to_server_.reset();
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
-
-    message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop message_loop_;
   scoped_ptr<ChromotingHostContext> context_;
   scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath host_config_path_;
   CompositeHostConfig config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
   std::string xmpp_auth_service_;
 
   std::string oauth_refresh_token_;
   bool oauth_use_official_client_id_;
 
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   bool allow_nat_traversal_;
+  std::string talkgadget_prefix_;
   scoped_ptr<base::files::FilePathWatcher> config_watcher_;
   scoped_ptr<base::DelayTimer<HostProcess> > config_updated_timer_;
 
   bool restarting_;
   bool shutting_down_;
 
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
@@ skipping 100 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)