This is the second CL of several that will eventually replace TokenService with

chrome/browser/signin/signin_manager_unittest.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/signin_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/signin/chrome_signin_manager_delegate.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
+#include "chrome/browser/signin/profile_oauth2_token_service.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/signin/token_service.h"
-#include "chrome/browser/signin/token_service_unittest.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/webdata/encryptor/encryptor.h"
 #include "content/public/browser/child_process_security_policy.h"
+#include "content/public/browser/notification_source.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_notification_tracker.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 17 matching lines @@
   service = new SigninManager(
       scoped_ptr<SigninManagerDelegate>(
           new ChromeSigninManagerDelegate(profile)));
   service->Initialize(profile, NULL);
   return service;
 }
 
 }  // namespace
 
 
-class SigninManagerTest : public TokenServiceTestHarness {
+class SigninManagerTest : public testing::Test {
  public:
    SigninManagerTest() : manager_(NULL) {}
    virtual ~SigninManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     manager_ = NULL;
     prefs_.reset(new TestingPrefServiceSimple);
     chrome::RegisterLocalState(prefs_->registry());
     TestingBrowserProcess::GetGlobal()->SetLocalState(
         prefs_.get());
-    TokenServiceTestHarness::SetUp();
+    TestingProfile::Builder builder;
+    builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
+                              FakeProfileOAuth2TokenService::Build);
+    profile_ = builder.Build();
     google_login_success_.ListenFor(
         chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
         content::Source<Profile>(profile()));
     google_login_failure_.ListenFor(chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED,
                                     content::Source<Profile>(profile()));
   }
 
   virtual void TearDown() OVERRIDE {
     // Destroy the SigninManager here, because it relies on profile() which is
     // freed in the base class.
     if (naked_manager_) {
       naked_manager_->Shutdown();
       naked_manager_.reset(NULL);
     }
     TestingBrowserProcess::GetGlobal()->SetLocalState(NULL);
-    prefs_.reset(NULL);
-    TokenServiceTestHarness::TearDown();
+
+    // Manually destroy PrefService and Profile so that they are shutdown
+    // in the correct order.  Both need to be destroyed before the
+    // |thread_bundle_| member.
+    prefs_.reset();
+    profile_.reset();
   }
 
+  TestingProfile* profile() { return profile_.get(); }
+
   // Create a signin manager as a service if other code will try to get it as
   // a PKS.
   void CreateSigninManagerAsService() {
     DCHECK(!manager_);
     DCHECK(!naked_manager_);
     manager_ = static_cast<SigninManager*>(
         SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
             profile(), SigninManagerBuild));
   }
 
@@ skipping 75 matching lines @@
                             cookies, "<html></html>");
   }
 
   void ExpectSignInWithCredentialsSuccess() {
     EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
 
     SimulateValidResponseSignInWithCredentials();
 
     EXPECT_FALSE(manager_->GetAuthenticatedUsername().empty());
 
-    // This is flow, the oauth2 credentials should already be available in
-    // the token service.
-    EXPECT_TRUE(service()->HasOAuthLoginToken());
+    ProfileOAuth2TokenService* token_service =
+        ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
+    EXPECT_TRUE(token_service->RefreshTokenIsAvailable(
+        manager_->GetAuthenticatedUsername()));
 
     // Should go into token service and stop.
     EXPECT_EQ(1U, google_login_success_.size());
     EXPECT_EQ(0U, google_login_failure_.size());
   }
 
   // Helper method that wraps the logic when signin with credentials
   // should fail. If |requestSent| is true, then simulate valid resopnse.
   // Otherwise the sign-in is aborted before any request is sent, thus no need
   // to simulatate response.
   void ExpectSignInWithCredentialsFail(bool requestSent) {
     EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
 
     if (requestSent)
       SimulateValidResponseSignInWithCredentials();
 
-    // The oauth2 credentials should not be available in the token service
-    // because the email was incorrect.
-    EXPECT_FALSE(service()->HasOAuthLoginToken());
+    ProfileOAuth2TokenService* token_service =
+        ProfileOAuth2TokenServiceFactory::GetForProfile(profile());
+    EXPECT_FALSE(token_service->RefreshTokenIsAvailable(
+        manager_->GetAuthenticatedUsername()));
 
     // Should go into token service and stop.
     EXPECT_EQ(0U, google_login_success_.size());
     EXPECT_EQ(1U, google_login_failure_.size());
   }
 
   void CompleteSigninCallback(const std::string& oauth_token) {
     oauth_tokens_fetched_.push_back(oauth_token);
     manager_->CompletePendingSignin();
   }
 
   void CancelSigninCallback(const std::string& oauth_token) {
     oauth_tokens_fetched_.push_back(oauth_token);
     manager_->SignOut();
   }
 
+  content::TestBrowserThreadBundle thread_bundle_;
   net::TestURLFetcherFactory factory_;
   scoped_ptr<SigninManager> naked_manager_;
   SigninManager* manager_;
+  scoped_ptr<TestingProfile> profile_;
   content::TestNotificationTracker google_login_success_;
   content::TestNotificationTracker google_login_failure_;
   std::vector<std::string> oauth_tokens_fetched_;
   scoped_ptr<TestingPrefServiceSimple> prefs_;
   std::vector<std::string> cookies_;
 };
 
 TEST_F(SigninManagerTest, SignInWithCredentials) {
   CreateSigninManagerAsService();
   EXPECT_TRUE(manager_->GetAuthenticatedUsername().empty());
@@ skipping 279 matching lines @@
             profile()->GetPrefs()->GetString(prefs::kGoogleServicesUsername));
   EXPECT_EQ("external@example.com", manager_->GetAuthenticatedUsername());
 }
 
 TEST_F(SigninManagerTest, SigninNotAllowed) {
   std::string user("user@google.com");
   profile()->GetPrefs()->SetString(prefs::kGoogleServicesUsername, user);
   profile()->GetPrefs()->SetBoolean(prefs::kSigninAllowed, false);
   CreateSigninManagerAsService();
 }