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.";
 
+  signal_strategy_->SetAuthInfo(oauth_credentials_->login,

[simonmorris, 2012/10/25 06:37:40]

Consider moving this where it was before, after the email address is checked.
That way you won't set a signal strategy that uses an invalid email address.

[Sergey Ulanov, 2012/10/26 21:05:00]

Done.

+                                access_token, "oauth2");
+  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;
   }
 
   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 = {

[rmsousa, 2012/10/24 23:18:47]

I'm not sure if we should move the client id/secret here. If in the future the
webapp (it2me) and the host end up using different OAuth flows (say, installed
native app for the host, web application flow for the webapp), they may have to
use different client ids (or we may want to use different ones intentionally for
other reasons).

[Sergey Ulanov, 2012/10/24 23:31:30]

It's likely that we won't need to use different client IDs, but if it ever turns
out that we do need it then it will be easy to add client_info parameter back.

+      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