[Chromoting] Hook up host talkgadget policy checks.

remoting/host/signaling_connector.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/signaling_connector.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "net/url_request/url_fetcher.h"
 #include "remoting/host/chromoting_host_context.h"
+#include "remoting/host/constants.h"
 #include "remoting/host/url_request_context.h"
 
 namespace remoting {
 
 namespace {
 
 // The delay between reconnect attempts will increase exponentially up
 // to the maximum specified here.
 const int kMaxReconnectDelaySeconds = 10 * 60;
 
 // Time when we we try to update OAuth token before its expiration.
 const int kTokenUpdateTimeBeforeExpirySeconds = 60;
 
 }  // namespace
 
 SignalingConnector::OAuthCredentials::OAuthCredentials(
     const std::string& login_value,
     const std::string& refresh_token_value,
     const OAuthClientInfo& client_info_value)
     : login(login_value),
       refresh_token(refresh_token_value),
       client_info(client_info_value) {
 }
 
 SignalingConnector::SignalingConnector(
     XmppSignalStrategy* signal_strategy,
+    ChromotingHostContext* context,
+    std::string talkgadget_prefix,
     const base::Closure& auth_failed_callback)
     : signal_strategy_(signal_strategy),
+      context_(context),
       auth_failed_callback_(auth_failed_callback),
+      talkgadget_prefix_(talkgadget_prefix),
+      found_talkgadget_(false),
       reconnect_attempts_(0),
       refreshing_oauth_token_(false) {
   DCHECK(!auth_failed_callback_.is_null());
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   signal_strategy_->AddListener(this);
   ScheduleTryReconnect();
 }
 
 SignalingConnector::~SignalingConnector() {
   signal_strategy_->RemoveListener(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void SignalingConnector::EnableOAuth(
-    scoped_ptr<OAuthCredentials> oauth_credentials,
-    net::URLRequestContextGetter* url_context) {
+    scoped_ptr<OAuthCredentials> oauth_credentials) {
   oauth_credentials_ = oauth_credentials.Pass();
   gaia_oauth_client_.reset(new GaiaOAuthClient(
-      OAuthProviderInfo::GetDefault(), url_context));
+      OAuthProviderInfo::GetDefault(), context_->url_request_context_getter()));
 }
 
+// SignalStrategy::Listener interface.
 void SignalingConnector::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   DCHECK(CalledOnValidThread());
 
   if (state == SignalStrategy::CONNECTED) {
     LOG(INFO) << "Signaling connected.";
     reconnect_attempts_ = 0;
   } else if (state == SignalStrategy::DISCONNECTED) {
     LOG(INFO) << "Signaling disconnected.";
     reconnect_attempts_++;
 
     // If authentication failed then we have an invalid OAuth token,
     // inform the upper layer about it.
     if (signal_strategy_->GetError() == SignalStrategy::AUTHENTICATION_FAILED) {
       auth_failed_callback_.Run();
     } else {
       ScheduleTryReconnect();
     }
   }
 }
 
 bool SignalingConnector::OnSignalStrategyIncomingStanza(
     const buzz::XmlElement* stanza) {
   return false;
 }
 
-void SignalingConnector::OnIPAddressChanged() {
-  DCHECK(CalledOnValidThread());
-  LOG(INFO) << "IP address has changed.";
-  ResetAndTryReconnect();
+// net::URLFetcherDelegate interface.

[Sergey Ulanov, 2012/08/24 19:43:33]

I don't think we need to duplicate this comment from the header. E.g. in this
particular case it would be more useful to comment that this is called in
response to talk-gadget HTTP request initiated in TryReconnect().

[garykac, 2012/08/27 22:34:57]

Done.

+void SignalingConnector::OnURLFetchComplete(const net::URLFetcher* source) {
+  int response = source->GetResponseCode();
+  if (response == 200) {
+    found_talkgadget_ = true;
+    url_fetcher_.reset(NULL);
+    TryReconnect();
+    return;
+  }
+  LOG(INFO) << "Failed to find talkgadget. Scheduling a reconnect.";
+  reconnect_attempts_++;
+  ScheduleTryReconnect();

[Sergey Ulanov, 2012/08/24 19:43:33]

If we know we are blocked then there isn't point in retrying the connection.
Should we shutdown the host in that case?

[garykac, 2012/08/27 22:34:57]

Not being able to reach the talkgadget could be for a number of reasons so we
need to retry.

Did you mean look specifically for a 404 response and kill the host?

 }
 
+// NetworkChangeNotifier::ConnectionTypeObserver interface.
 void SignalingConnector::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK(CalledOnValidThread());
   if (type != net::NetworkChangeNotifier::CONNECTION_NONE) {
     LOG(INFO) << "Network state changed to online.";
     ResetAndTryReconnect();
   }
 }
 
+// NetworkChangeNotifier::IPAddressObserver interface.
+void SignalingConnector::OnIPAddressChanged() {
+  DCHECK(CalledOnValidThread());
+  LOG(INFO) << "IP address has changed.";
+  ResetAndTryReconnect();
+}
+
+// GaiaOAuthClient::Delegate interface.
 void SignalingConnector::OnRefreshTokenResponse(const std::string& user_email,
                                                 const std::string& access_token,
                                                 int expires_seconds) {
   DCHECK(CalledOnValidThread());
   DCHECK(oauth_credentials_.get());
   LOG(INFO) << "Received OAuth token.";
 
   if (user_email != oauth_credentials_->login) {
     LOG(ERROR) << "OAuth token and email address do not refer to "
         "the same account.";
@@ skipping 43 matching lines @@
 void SignalingConnector::ResetAndTryReconnect() {
   DCHECK(CalledOnValidThread());
   signal_strategy_->Disconnect();
   reconnect_attempts_ = 0;
   timer_.Stop();
   ScheduleTryReconnect();
 }
 
 void SignalingConnector::TryReconnect() {
   DCHECK(CalledOnValidThread());
+
+  if (!found_talkgadget_) {
+    std::string talkgadget_url("https://");
+    if (talkgadget_prefix_.empty()) {
+      talkgadget_url += kDefaultHostTalkGadgetPrefix;
+    } else {
+      talkgadget_url += talkgadget_prefix_;
+    }
+    talkgadget_url += kTalkGadgetURL;
+    LOG(INFO) << "Verifying connection to " << talkgadget_url;
+    url_fetcher_.reset(net::URLFetcher::Create(GURL(talkgadget_url),
+                                               net::URLFetcher::GET, this));
+    url_fetcher_->SetRequestContext(context_->url_request_context_getter());
+    url_fetcher_->Start();
+    return;
+  }
+
   if (signal_strategy_->GetState() == SignalStrategy::DISCONNECTED) {
+
     bool need_new_auth_token = oauth_credentials_.get() &&
         (auth_token_expiry_time_.is_null() ||
          base::Time::Now() >= auth_token_expiry_time_);
     if (need_new_auth_token) {
       RefreshOAuthToken();
     } else {
       LOG(INFO) << "Attempting to connect signaling.";
       signal_strategy_->Connect();
     }
   }
 }
 
 void SignalingConnector::RefreshOAuthToken() {
   DCHECK(CalledOnValidThread());
   LOG(INFO) << "Refreshing OAuth token.";
   DCHECK(!refreshing_oauth_token_);
 
   refreshing_oauth_token_ = true;
   gaia_oauth_client_->RefreshToken(
       oauth_credentials_->client_info,
       oauth_credentials_->refresh_token, this);
 }
 
 }  // namespace remoting