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 {

[Rick Campbell, 2011/11/28 22:51:07]

See comment in header.  I recommend removing these.

[Munjal (Google), 2011/11/28 23:41:14]

Replied there.

+  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 (service == GaiaConstants::kLSOService) {

[Rick Campbell, 2011/11/28 22:51:07]

Is there another way to accomplish this?  Splicing in an explicit test here is
troubling to me.  I would be happier if this could be done by code that already
handles the issuance of the LSOService token.

At a minimum, this should be documented inline, but hopefully this logic can
live elsewhere.

[Munjal (Google), 2011/11/28 23:41:14]

I thought about that but decided that this was the best option right now since
the fact that creating an oauth login scoped token depends on "lso" service
token is implementation detail which calelrs should not worry about.

I added a comment here.

+    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());
 }