Verify that xmpp_login specified in the config matches auth token.

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 "remoting/host/chromoting_host_context.h"
 #include "remoting/host/url_request_context.h"
@@ skipping 13 matching lines @@
 
 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)
+SignalingConnector::SignalingConnector(
+    XmppSignalStrategy* signal_strategy,
+    const base::Closure& auth_failed_callback)
     : signal_strategy_(signal_strategy),
+      auth_failed_callback_(auth_failed_callback),
       reconnect_attempts_(0),
       refreshing_oauth_token_(false) {
+  DCHECK(!auth_failed_callback_.is_null());
   net::NetworkChangeNotifier::AddOnlineStateObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   signal_strategy_->AddListener(this);
   ScheduleTryReconnect();
 }
 
 SignalingConnector::~SignalingConnector() {
   signal_strategy_->RemoveListener(this);
   net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void SignalingConnector::EnableOAuth(
     scoped_ptr<OAuthCredentials> oauth_credentials,
-    const base::Closure& oauth_failed_callback,
     net::URLRequestContextGetter* url_context) {
   oauth_credentials_ = oauth_credentials.Pass();
-  oauth_failed_callback_ = oauth_failed_callback;
   gaia_oauth_client_.reset(new GaiaOAuthClient(kGaiaOAuth2Url, url_context));
 }
 
 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_++;
-    ScheduleTryReconnect();
+
+    // 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();
+    }
   }
 }
 
 void SignalingConnector::OnIPAddressChanged() {
   DCHECK(CalledOnValidThread());
   LOG(INFO) << "IP address has changed.";
   ResetAndTryReconnect();
 }
 
 void SignalingConnector::OnOnlineStateChanged(bool online) {
@@ skipping 19 matching lines @@
   // Now that we've got the new token, try to connect using it.
   DCHECK_EQ(signal_strategy_->GetState(), SignalStrategy::DISCONNECTED);
   signal_strategy_->Connect();
 }
 
 void SignalingConnector::OnOAuthError() {
   DCHECK(CalledOnValidThread());
   LOG(ERROR) << "OAuth: invalid credentials.";
   refreshing_oauth_token_ = false;
   reconnect_attempts_++;
-  oauth_failed_callback_.Run();
+  auth_failed_callback_.Run();
 }
 
 void SignalingConnector::OnNetworkError(int response_code) {
   DCHECK(CalledOnValidThread());
   LOG(ERROR) << "Network error when trying to update OAuth token: "
              << response_code;
   refreshing_oauth_token_ = false;
   reconnect_attempts_++;
   ScheduleTryReconnect();
 }
@@ skipping 36 matching lines @@
   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