Integrate OAuth2 login token generation into TokenService:

chrome/browser/net/gaia/token_service.cc

 // Copyright (c) 2011 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 "chrome/browser/net/gaia/token_service.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 142 matching lines @@
   if (web_data_service_.get())
     web_data_service_->SetTokenForService(service, auth_token);
 }
 
 void TokenService::EraseTokensFromDB() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (web_data_service_.get())
     web_data_service_->RemoveAllTokens();
 }
 
+// static
+int TokenService::GetServiceIndex(const std::string& service) {
+  for (int i = 0; i < kNumServices; ++i) {
+    if (kServices[i] == service)
+      return i;
+  }
+  return -1;
+}
+
 bool TokenService::AreCredentialsValid() const {
   return !credentials_.lsid.empty() && !credentials_.sid.empty();
 }
 
 bool TokenService::HasLsid() const {
   return !credentials_.lsid.empty();
 }
 
 const std::string& TokenService::GetLsid() const {
   return credentials_.lsid;
@@ skipping 59 matching lines @@
 const std::string& TokenService::GetTokenForService(
     const char* const service) const {
 
   if (token_map_.count(service) > 0) {
     // Note map[key] is not const.
     return (*token_map_.find(service)).second;
   }
   return EmptyString();
 }
 
+bool TokenService::HasOAuthLoginToken() const {
+  return HasTokenForService(GaiaConstants::kGaiaOAuth2LoginRefreshToken);
+}
+
+const std::string& TokenService::GetOAuth2LoginRefreshToken() const {
+  return GetTokenForService(GaiaConstants::kGaiaOAuth2LoginRefreshToken);
+}
+
+const std::string& TokenService::GetOAuth2LoginAccessToken() const {
+  return GetTokenForService(GaiaConstants::kGaiaOAuth2LoginAccessToken);
+}
+
 // Note that this can fire twice or more for any given service.
 // It can fire once from the DB read, and then once from the initial
 // fetcher. Future fetches can cause more notification firings.
 // The DB read will not however fire a notification if the fetcher
 // returned first. So it's always safe to use the latest notification.
 void TokenService::FireTokenAvailableNotification(
     const std::string& service,
     const std::string& auth_token) {
 
   TokenAvailableDetails details(service, auth_token);
@@ skipping 20 matching lines @@
   FireTokenAvailableNotification(service, auth_token);
 }
 
 void TokenService::OnIssueAuthTokenSuccess(const std::string& service,
                                            const std::string& auth_token) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Got an authorization token for " << service;
   token_map_[service] = auth_token;
   FireTokenAvailableNotification(service, auth_token);
   SaveAuthTokenToDB(service, auth_token);
+  // If we got ClientLogin token for "lso" service, then start fetching OAuth2
+  // login scoped token pair.
+  if (service == GaiaConstants::kLSOService) {
+    int index = GetServiceIndex(service);
+    DCHECK_NE(-1, index);
+    fetchers_[index]->StartOAuthLoginTokenFetch(auth_token);
+  }
 }
 
 void TokenService::OnIssueAuthTokenFailure(const std::string& service,
     const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LOG(WARNING) << "Auth token issuing failed for service:" << service;
   FireTokenRequestFailedNotification(service, error);
 }
 
+void TokenService::OnOAuthLoginTokenSuccess(const std::string& refresh_token,
+                                            const std::string& access_token,
+                                            int expires_in_secs) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  VLOG(1) << "Got OAuth2 login token pair";
+  token_map_[GaiaConstants::kGaiaOAuth2LoginRefreshToken] = refresh_token;
+  token_map_[GaiaConstants::kGaiaOAuth2LoginAccessToken] = access_token;
+  SaveAuthTokenToDB(GaiaConstants::kGaiaOAuth2LoginRefreshToken,
+      refresh_token);
+  SaveAuthTokenToDB(GaiaConstants::kGaiaOAuth2LoginAccessToken,
+      access_token);
+  // We don't save expiration information for now.
+
+  FireTokenAvailableNotification(GaiaConstants::kGaiaOAuth2LoginRefreshToken,
+      refresh_token);
+}
+
+void TokenService::OnOAuthLoginTokenFailure(
+   const GoogleServiceAuthError& error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LOG(WARNING) << "OAuth2 login token pair fetch failed:";
+  FireTokenRequestFailedNotification(
+      GaiaConstants::kGaiaOAuth2LoginRefreshToken, error);
+}
+
 void TokenService::OnOAuthGetAccessTokenSuccess(const std::string& token,
                                                 const std::string& secret) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "TokenService::OnOAuthGetAccessTokenSuccess";
   SaveAuthTokenToDB(GaiaConstants::kGaiaOAuthToken, token);
   SaveAuthTokenToDB(GaiaConstants::kGaiaOAuthSecret, secret);
   UpdateOAuthCredentials(token, secret);
 }
 
 void TokenService::OnOAuthGetAccessTokenFailure(
@@ skipping 40 matching lines @@
       content::Source<TokenService>(this),
       content::NotificationService::NoDetails());
 }
 
 // Load tokens from the db_token map into the in memory token map.
 void TokenService::LoadTokensIntoMemory(
     const std::map<std::string, std::string>& db_tokens,
     std::map<std::string, std::string>* in_memory_tokens) {
 
   for (int i = 0; i < kNumServices; i++) {
-    // OnIssueAuthTokenSuccess should come from the same thread.
-    // If a token is already present in the map, it could only have
-    // come from a DB read or from IssueAuthToken. Since we should never
-    // fetch from the DB twice in a browser session, it must be from
-    // OnIssueAuthTokenSuccess, which is a live fetcher.
-    //
-    // Network fetched tokens take priority over DB tokens, so exclude tokens
-    // which have already been loaded by the fetcher.
-    if (!in_memory_tokens->count(kServices[i]) &&
-        db_tokens.count(kServices[i])) {
-      std::string db_token = db_tokens.find(kServices[i])->second;
-      if (!db_token.empty()) {
-        VLOG(1) << "Loading " << kServices[i] << " token from DB: " << db_token;
-        (*in_memory_tokens)[kServices[i]] = db_token;
-        FireTokenAvailableNotification(kServices[i], db_token);
-        // Failures are only for network errors.
-      }
-    }
+    LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens, kServices[i]);
   }
+  LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
+      GaiaConstants::kGaiaOAuth2LoginRefreshToken);
+  LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
+      GaiaConstants::kGaiaOAuth2LoginAccessToken);
 
   if (credentials_.lsid.empty() && credentials_.sid.empty()) {
     // Look for GAIA SID and LSID tokens.  If we have both, and the current
     // crendentials are empty, update the credentials.
     std::string lsid;
     std::string sid;
 
     if (db_tokens.count(GaiaConstants::kGaiaLsid) > 0)
       lsid = db_tokens.find(GaiaConstants::kGaiaLsid)->second;
 
     if (db_tokens.count(GaiaConstants::kGaiaSid) > 0)
       sid = db_tokens.find(GaiaConstants::kGaiaSid)->second;
 
     if (!lsid.empty() && !sid.empty()) {
       UpdateCredentials(GaiaAuthConsumer::ClientLoginResult(sid,
                                                             lsid,
                                                             std::string(),
                                                             std::string()));
     }
   }
 
   for (int i = 0; i < kNumOAuthServices; i++) {
-    // OnIssueAuthTokenSuccess should come from the same thread.
-    // If a token is already present in the map, it could only have
-    // come from a DB read or from IssueAuthToken. Since we should never
-    // fetch from the DB twice in a browser session, it must be from
-    // OnIssueAuthTokenSuccess, which is a live fetcher.
-    //
-    // Network fetched tokens take priority over DB tokens, so exclude tokens
-    // which have already been loaded by the fetcher.
-    if (!in_memory_tokens->count(kOAuthServices[i]) &&
-        db_tokens.count(kOAuthServices[i])) {
-      std::string db_token = db_tokens.find(kOAuthServices[i])->second;
-      if (!db_token.empty()) {
-        VLOG(1) << "Loading " << kOAuthServices[i] << " OAuth token from DB: "
-                << db_token;
-        (*in_memory_tokens)[kOAuthServices[i]] = db_token;
-        FireTokenAvailableNotification(kOAuthServices[i], db_token);
-        // Failures are only for network errors.
-      }
-    }
+    LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens, kOAuthServices[i]);
   }
 
   if (oauth_token_.empty() && oauth_secret_.empty()) {
     // Look for GAIA OAuth1 access token and secret.  If we have both, and the
     // current crendentials are empty, update the credentials.
     std::string oauth_token;
     std::string oauth_secret;
 
     if (db_tokens.count(GaiaConstants::kGaiaOAuthToken) > 0)
       oauth_token = db_tokens.find(GaiaConstants::kGaiaOAuthToken)->second;
 
     if (db_tokens.count(GaiaConstants::kGaiaOAuthSecret) > 0)
       oauth_secret = db_tokens.find(GaiaConstants::kGaiaOAuthSecret)->second;
 
     if (!oauth_token.empty() && !oauth_secret.empty()) {
       UpdateOAuthCredentials(oauth_token, oauth_secret);
     }
   }
 }
 
+void TokenService::LoadSingleTokenIntoMemory(
+    const std::map<std::string, std::string>& db_tokens,
+    std::map<std::string, std::string>* in_memory_tokens,
+    const std::string& service) {
+  // OnIssueAuthTokenSuccess should come from the same thread.
+  // If a token is already present in the map, it could only have
+  // come from a DB read or from IssueAuthToken. Since we should never
+  // fetch from the DB twice in a browser session, it must be from
+  // OnIssueAuthTokenSuccess, which is a live fetcher.
+  //
+  // Network fetched tokens take priority over DB tokens, so exclude tokens
+  // which have already been loaded by the fetcher.
+  if (!in_memory_tokens->count(service) && db_tokens.count(service)) {
+    std::string db_token = db_tokens.find(service)->second;
+    if (!db_token.empty()) {
+      VLOG(1) << "Loading " << service << " token from DB: " << db_token;
+      (*in_memory_tokens)[service] = db_token;
+      FireTokenAvailableNotification(service, db_token);
+      // Failures are only for network errors.
+    }
+  }
+}
+
 void TokenService::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_TOKEN_UPDATED);
   TokenAvailableDetails* tok_details =
       content::Details<TokenAvailableDetails>(details).ptr();
   OnIssueAuthTokenSuccess(tok_details->service(), tok_details->token());
 }