Remove GaiaOauthClient and GaiaUserEmailFetcher from remoting.

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 "google_apis/google_api_keys.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "remoting/host/dns_blackhole_checker.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)
+    const std::string& refresh_token_value)
     : login(login_value),
-      refresh_token(refresh_token_value),
-      client_info(client_info_value) {
+      refresh_token(refresh_token_value) {
 }
 
 SignalingConnector::SignalingConnector(
     XmppSignalStrategy* signal_strategy,
     scoped_refptr<net::URLRequestContextGetter> url_request_context_getter,
     scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker,
     const base::Closure& auth_failed_callback)
     : signal_strategy_(signal_strategy),
       url_request_context_getter_(url_request_context_getter),
       auth_failed_callback_(auth_failed_callback),
@@ skipping 10 matching lines @@
 
 SignalingConnector::~SignalingConnector() {
   signal_strategy_->RemoveListener(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 void SignalingConnector::EnableOAuth(
     scoped_ptr<OAuthCredentials> oauth_credentials) {
   oauth_credentials_ = oauth_credentials.Pass();
-  gaia_oauth_client_.reset(new GaiaOAuthClient(
-      OAuthProviderInfo::GetDefault(), url_request_context_getter_));
+  gaia_oauth_client_.reset(new gaia::GaiaOAuthClient(
+      gaia::kGaiaOAuth2Url, url_request_context_getter_));
 }
 
 void SignalingConnector::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   DCHECK(CalledOnValidThread());
 
   if (state == SignalStrategy::CONNECTED) {
     LOG(INFO) << "Signaling connected.";
     reconnect_attempts_ = 0;
   } else if (state == SignalStrategy::DISCONNECTED) {
@@ skipping 23 matching lines @@
     ResetAndTryReconnect();
   }
 }
 
 void SignalingConnector::OnIPAddressChanged() {
   DCHECK(CalledOnValidThread());
   LOG(INFO) << "IP address has changed.";
   ResetAndTryReconnect();
 }
 
-void SignalingConnector::OnRefreshTokenResponse(const std::string& user_email,
-                                                const std::string& access_token,
-                                                int expires_seconds) {
+void SignalingConnector::OnGetTokensResponse(const std::string& user_email,
+                                             const std::string& access_token,
+                                             int expires_seconds) {
+  NOTREACHED();
+}
+
+void SignalingConnector::OnRefreshTokenResponse(
+    const std::string& access_token,
+    int expires_seconds) {
   DCHECK(CalledOnValidThread());
   DCHECK(oauth_credentials_.get());
   LOG(INFO) << "Received OAuth token.";
 
+  oauth_access_token_ = access_token;
+  auth_token_expiry_time_ = base::Time::Now() +
+      base::TimeDelta::FromSeconds(expires_seconds) -
+      base::TimeDelta::FromSeconds(kTokenUpdateTimeBeforeExpirySeconds);
+
+  gaia_oauth_client_->GetUserInfo(access_token, 1, this);
+}
+
+void SignalingConnector::OnGetUserInfoResponse(const std::string& user_email) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(oauth_credentials_.get());
+  LOG(INFO) << "Received user info.";
+
   if (user_email != oauth_credentials_->login) {
     LOG(ERROR) << "OAuth token and email address do not refer to "
         "the same account.";
     auth_failed_callback_.Run();
     return;
   }
 
+  signal_strategy_->SetAuthInfo(oauth_credentials_->login,
+                                oauth_access_token_, "oauth2");
   refreshing_oauth_token_ = false;
-  auth_token_expiry_time_ = base::Time::Now() +
-      base::TimeDelta::FromSeconds(expires_seconds) -
-      base::TimeDelta::FromSeconds(kTokenUpdateTimeBeforeExpirySeconds);
-  signal_strategy_->SetAuthInfo(oauth_credentials_->login,
-                                access_token, "oauth2");
 
-  // Now that we've got the new token, try to connect using it.
+  // Now that we've refreshed the token and verified that it's for the correct
+  // user account, try to connect using the new token.
   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_++;
   auth_failed_callback_.Run();
@@ skipping 62 matching lines @@
       signal_strategy_->Connect();
     }
   }
 }
 
 void SignalingConnector::RefreshOAuthToken() {
   DCHECK(CalledOnValidThread());
   LOG(INFO) << "Refreshing OAuth token.";
   DCHECK(!refreshing_oauth_token_);
 
+  gaia::OAuthClientInfo client_info = {
+      google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING),
+      google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING),
+      // Redirect URL is only used when getting tokens from auth code. It
+      // is not required when getting access tokens.
+      ""
+  };
+
   refreshing_oauth_token_ = true;
   gaia_oauth_client_->RefreshToken(
-      oauth_credentials_->client_info,
-      oauth_credentials_->refresh_token, this);
+      client_info, oauth_credentials_->refresh_token, 1, this);
 }
 
 }  // namespace remoting