Build a new TokenCacheService so I can stop using TokenService for something it wasn't designed for.

chrome/browser/signin/token_service.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 "chrome/browser/signin/token_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
@@ skipping 82 matching lines @@
   if (cmd_line->HasSwitch(switches::kSetToken)) {
     std::string value = cmd_line->GetSwitchValueASCII(switches::kSetToken);
     int separator = value.find(':');
     std::string service = value.substr(0, separator);
     std::string token = value.substr(separator + 1);
     token_map_[service] = token;
     SaveAuthTokenToDB(service, token);
   }
 }
 
-// TODO(petewil) We should refactor the token_service so it does not both
-// store tokens and fetch them.  Move the key-value storage out of
-// token_service, and leave the token fetching in token_service.
-
-void TokenService::AddAuthTokenManually(const std::string& service,

[Andrew T Wilson (Slow), 2013/03/01 17:50:54]

I think we should keep this code as it's the primary way for people to feed
tokens into TokenService (like the sync token from SyncBackendHost)

[Pete Williamson, 2013/03/04 18:32:53]

Done.

-                                        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);
-
-// We don't ever want to fetch OAuth2 tokens from LSO service token in case
-// when ChromeOS is in forced OAuth2 use mode. OAuth2 token should only
-// arrive into token service exclusively through UpdateCredentialsWithOAuth2.
-#if !defined(OS_CHROMEOS)
-  // If we got ClientLogin token for "lso" service, and we don't already have
-  // OAuth2 tokens, start fetching OAuth2 login scoped token pair.
-  if (service == GaiaConstants::kLSOService && !HasOAuthLoginToken()) {
-    int index = GetServiceIndex(service);
-    CHECK_GE(index, 0);
-    fetchers_[index]->StartLsoForOAuthLoginTokenExchange(auth_token);
-  }
-#endif
-}
-
-
 void TokenService::ResetCredentialsInMemory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Terminate any running fetchers. Callbacks will not return.
   for (size_t i = 0; i < arraysize(kServices); ++i) {
     fetchers_[i].reset();
   }
 
   // Cancel pending loads. Callbacks will not return.
   if (token_loading_query_) {
@@ skipping 186 matching lines @@
 void TokenService::IssueAuthTokenForTest(const std::string& service,
                                          const std::string& auth_token) {
   token_map_[service] = auth_token;
   FireTokenAvailableNotification(service, auth_token);
 }
 
 void TokenService::OnIssueAuthTokenSuccess(const std::string& service,
                                            const std::string& auth_token) {
   FOR_DIAGNOSTICS_OBSERVERS(
       NotifyTokenReceivedSuccess(service, auth_token, true));
-  AddAuthTokenManually(service, 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);
+
+// We don't ever want to fetch OAuth2 tokens from LSO service token in case
+// when ChromeOS is in forced OAuth2 use mode. OAuth2 token should only
+// arrive into token service exclusively through UpdateCredentialsWithOAuth2.
+#if !defined(OS_CHROMEOS)
+  // If we got ClientLogin token for "lso" service, and we don't already have
+  // OAuth2 tokens, start fetching OAuth2 login scoped token pair.
+  if (service == GaiaConstants::kLSOService && !HasOAuthLoginToken()) {
+    int index = GetServiceIndex(service);
+    CHECK_GE(index, 0);
+    fetchers_[index]->StartLsoForOAuthLoginTokenExchange(auth_token);
+  }
+#endif
 }
 
 void TokenService::OnIssueAuthTokenFailure(const std::string& service,
     const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LOG(WARNING) << "Auth token issuing failed for service:" << service
                << ", error: " << error.ToString();
   FOR_DIAGNOSTICS_OBSERVERS(
       NotifyTokenReceivedFailure(service, error.ToString()));
   FireTokenRequestFailedNotification(service, error);
@@ skipping 66 matching lines @@
     DCHECK(NULL == fetchers_[i].get());
   }
 
   for (size_t i = 0; i < arraysize(kServices); i++) {
     LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens, kServices[i]);
   }
   LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
       GaiaConstants::kGaiaOAuth2LoginRefreshToken);
   LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
       GaiaConstants::kGaiaOAuth2LoginAccessToken);
-  // TODO(petewil): Remove next line when we refactor key-value
-  // storage out of token_service.
-  LoadSingleTokenIntoMemory(db_tokens, in_memory_tokens,
-      GaiaConstants::kObfuscatedGaiaId);
 
   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;
 
@@ skipping 43 matching lines @@
 
 void TokenService::AddSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.AddObserver(observer);
 }
 
 void TokenService::RemoveSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.RemoveObserver(observer);
 }