Integrate OAuth2 login token generation into TokenService:

chrome/browser/net/gaia/token_service.cc

Index: chrome/browser/net/gaia/token_service.cc
===================================================================
--- chrome/browser/net/gaia/token_service.cc	(revision 111499)
+++ chrome/browser/net/gaia/token_service.cc	(working copy)
@@ -160,6 +160,15 @@
     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();
 }
@@ -239,6 +248,18 @@
   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.
@@ -279,6 +300,11 @@
   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,
@@ -288,6 +314,31 @@
   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));
@@ -348,25 +399,12 @@
     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
@@ -389,25 +427,7 @@
   }
 
   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()) {
@@ -428,6 +448,29 @@
   }
 }
 
+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) {