Making OAuth2TokenService multi-login aware, updating callers, minor fixes

chrome/browser/sync/test_profile_sync_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/sync/test_profile_sync_service.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/glue/data_type_controller.h"
@@ skipping 190 matching lines @@
 
 syncer::WeakHandle<syncer::JsEventHandler>
 TestProfileSyncService::GetJsEventHandler() {
   return syncer::WeakHandle<syncer::JsEventHandler>();
 }
 
 TestProfileSyncService::TestProfileSyncService(
     ProfileSyncComponentsFactory* factory,
     Profile* profile,
     SigninManagerBase* signin,
-    OAuth2TokenService* oauth2_token_service,
+    ProfileOAuth2TokenService* oauth2_token_service,
     ProfileSyncService::StartBehavior behavior,
     bool synchronous_backend_initialization)
         : ProfileSyncService(factory,
                              profile,
                              signin,
                              oauth2_token_service,
                              behavior),
     synchronous_backend_initialization_(
         synchronous_backend_initialization),
     synchronous_sync_configuration_(false),
     set_initial_sync_ended_on_init_(true),
     fail_initial_download_(false),
     storage_option_(syncer::STORAGE_IN_MEMORY) {
   SetSyncSetupCompleted();
 }
 
 TestProfileSyncService::~TestProfileSyncService() {
 }
 
 // static
 BrowserContextKeyedService* TestProfileSyncService::BuildAutoStartAsyncInit(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
   SigninManagerBase* signin =
       SigninManagerFactory::GetForProfile(profile);
-  OAuth2TokenService* oauth2_token_service =
+  ProfileOAuth2TokenService* oauth2_token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   ProfileSyncComponentsFactoryMock* factory =
       new ProfileSyncComponentsFactoryMock();
   return new TestProfileSyncService(factory,
                                     profile,
                                     signin,
                                     oauth2_token_service,
                                     ProfileSyncService::AUTO_START,
                                     false);
 }
@@ skipping 67 matching lines @@
       sync_prefs_.AsWeakPtr(),
       id_factory_,
       callback_,
       set_initial_sync_ended_on_init_,
       synchronous_backend_initialization_,
       fail_initial_download_,
       storage_option_));
 }
 
 scoped_ptr<OAuth2TokenService::Request> FakeOAuth2TokenService::StartRequest(
+    const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   // Ensure token in question is cached and never expires. Request will succeed
   // without network IO.
   RegisterCacheEntry("test_client_id",
-                     GetRefreshToken(),
+                     account_id,
                      scopes,
                      "access_token",
                      base::Time::Max());
-  return ProfileOAuth2TokenService::StartRequest(scopes, consumer);
+  return ProfileOAuth2TokenService::StartRequest(account_id, scopes, consumer);
 }
 
 BrowserContextKeyedService* FakeOAuth2TokenService::BuildTokenService(
     content::BrowserContext* context) {
   Profile* profile = static_cast<Profile*>(context);
 
   FakeOAuth2TokenService* service = new FakeOAuth2TokenService();
   service->Initialize(profile);
   return service;
 }
+
+void FakeOAuth2TokenService::PersistCredentials(
+    const std::string& account_id,
+    const std::string& refresh_token) {
+  // Disabling the token persistence.
+}
+
+void FakeOAuth2TokenService::ClearPersistedCredentials(
+    const std::string& account_id) {
+  // Disabling the token persistence.
+}