Revert of non-new-profile-management creates a "no-op" style account_reconcilor,

chrome/browser/signin/account_reconcilor_unittest.cc

 // Copyright 2013 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 "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/signin/account_reconcilor_factory.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h"
 #include "chrome/browser/signin/fake_signin_manager.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
-#include "chrome/test/base/testing_profile_manager.h"
 #include "components/signin/core/browser/account_reconcilor.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
-#include "components/signin/core/common/signin_switches.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 const char kTestEmail[] = "user@gmail.com";
 
 class MockAccountReconcilor : public testing::StrictMock<AccountReconcilor> {
  public:
   static KeyedService* Build(content::BrowserContext* context);
 
   MockAccountReconcilor(ProfileOAuth2TokenService* token_service,
                         SigninManagerBase* signin_manager,
                         SigninClient* client);
   virtual ~MockAccountReconcilor() {}
 
   MOCK_METHOD1(PerformMergeAction, void(const std::string& account_id));
-  MOCK_METHOD1(PerformStartRemoveAction, void(const std::string& account_id));
+  MOCK_METHOD1(StartRemoveAction, void(const std::string& account_id));
   MOCK_METHOD3(
-      PerformFinishRemoveAction,
+      FinishRemoveAction,
       void(const std::string& account_id,
            const GoogleServiceAuthError& error,
            const std::vector<std::pair<std::string, bool> >& accounts));
   MOCK_METHOD2(PerformAddToChromeAction, void(const std::string& account_id,
                                               int session_index));
   MOCK_METHOD0(PerformLogoutAllAccountsAction, void());
 };
 
 // static
 KeyedService* MockAccountReconcilor::Build(content::BrowserContext* context) {
@@ skipping 15 matching lines @@
                                              client) {}
 
 }  // namespace
 
 class AccountReconcilorTest : public testing::Test {
  public:
   AccountReconcilorTest();
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  TestingProfile* profile() { return profile_; }
+  TestingProfile* profile() { return profile_.get(); }
   FakeSigninManagerForTesting* signin_manager() { return signin_manager_; }
   FakeProfileOAuth2TokenService* token_service() { return token_service_; }
 
   void SetFakeResponse(const std::string& url,
                        const std::string& data,
                        net::HttpStatusCode code,
                        net::URLRequestStatus::Status status) {
     url_fetcher_factory_.SetFakeResponse(GURL(url), data, code, status);
   }
 
   MockAccountReconcilor* GetMockReconcilor();
 
   void SimulateMergeSessionCompleted(
       MergeSessionHelper::Observer* observer,
       const std::string& account_id,
       const GoogleServiceAuthError& error);
 
   void SimulateRefreshTokenFetched(
       AccountReconcilor* reconcilor,
       const std::string& account_id,
       const std::string& refresh_token);
 
  private:
   content::TestBrowserThreadBundle bundle_;
-  TestingProfile* profile_;
+  scoped_ptr<TestingProfile> profile_;
   FakeSigninManagerForTesting* signin_manager_;
   FakeProfileOAuth2TokenService* token_service_;
   MockAccountReconcilor* mock_reconcilor_;
   net::FakeURLFetcherFactory url_fetcher_factory_;
-  TestingProfileManager* testing_profile_manager_;
 };
 
 AccountReconcilorTest::AccountReconcilorTest()
     : signin_manager_(NULL),
       token_service_(NULL),
       mock_reconcilor_(NULL),
       url_fetcher_factory_(NULL) {}
 
 void AccountReconcilorTest::SetUp() {
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      switches::kNewProfileManagement);
-
-  testing_profile_manager_ =
-      new TestingProfileManager(TestingBrowserProcess::GetGlobal());
-  ASSERT_TRUE(testing_profile_manager_->SetUp());
-
-  TestingProfile::TestingFactories factories;
-  factories.push_back(std::make_pair(
-      ProfileOAuth2TokenServiceFactory::GetInstance(),
-      BuildFakeProfileOAuth2TokenService));
-  factories.push_back(std::make_pair(SigninManagerFactory::GetInstance(),
-      FakeSigninManagerBase::Build));
-  factories.push_back(std::make_pair(AccountReconcilorFactory::GetInstance(),
-      MockAccountReconcilor::Build));
-
-  profile_ = testing_profile_manager_->CreateTestingProfile("name",
-                              scoped_ptr<PrefServiceSyncable>(),
-                              base::UTF8ToUTF16("name"), 0, std::string(),
-                              factories);
+  TestingProfile::Builder builder;
+  builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
+                            BuildFakeProfileOAuth2TokenService);
+  builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
+                            FakeSigninManagerBase::Build);
+  builder.AddTestingFactory(AccountReconcilorFactory::GetInstance(),
+                            MockAccountReconcilor::Build);
+  profile_ = builder.Build();
 
   signin_manager_ =
       static_cast<FakeSigninManagerForTesting*>(
           SigninManagerFactory::GetForProfile(profile()));
 
   token_service_ =
       static_cast<FakeProfileOAuth2TokenService*>(
           ProfileOAuth2TokenServiceFactory::GetForProfile(profile()));
 }
 
 void AccountReconcilorTest::TearDown() {
-  // The |testing_profile_manager_| will handle destroying the profile.
-  delete testing_profile_manager_;
+  // Destroy the profile before all threads are torn down.
+  profile_.reset();
 }
 
 MockAccountReconcilor* AccountReconcilorTest::GetMockReconcilor() {
   if (!mock_reconcilor_) {
     mock_reconcilor_ =
         static_cast<MockAccountReconcilor*>(
             AccountReconcilorFactory::GetForProfile(profile()));
   }
 
   return mock_reconcilor_;
@@ skipping 21 matching lines @@
 }
 
 #if !defined(OS_CHROMEOS)
 
 TEST_F(AccountReconcilorTest, SigninManagerRegistration) {
   AccountReconcilor* reconcilor =
       AccountReconcilorFactory::GetForProfile(profile());
   ASSERT_TRUE(reconcilor);
   ASSERT_FALSE(reconcilor->IsRegisteredWithTokenService());
 
-  signin_manager()->set_password("password");
   signin_manager()->OnExternalSigninCompleted(kTestEmail);
   ASSERT_TRUE(reconcilor->IsRegisteredWithTokenService());
 
   EXPECT_CALL(*GetMockReconcilor(), PerformLogoutAllAccountsAction());
 
   signin_manager()->SignOut();
   ASSERT_FALSE(reconcilor->IsRegisteredWithTokenService());
 }
 
 TEST_F(AccountReconcilorTest, Reauth) {
   signin_manager()->SetAuthenticatedUsername(kTestEmail);
-  signin_manager()->set_password("password");
 
   AccountReconcilor* reconcilor =
       AccountReconcilorFactory::GetForProfile(profile());
   ASSERT_TRUE(reconcilor);
   ASSERT_TRUE(reconcilor->IsRegisteredWithTokenService());
 
   // Simulate reauth.  The state of the reconcilor should not change.
   signin_manager()->OnExternalSigninCompleted(kTestEmail);
   ASSERT_TRUE(reconcilor->IsRegisteredWithTokenService());
 }
@@ skipping 216 matching lines @@
   ASSERT_FALSE(reconcilor->AreAllRefreshTokensChecked());
 
   token_service()->IssueAllTokensForAccount("user@gmail.com", "access_token",
       base::Time::Now() + base::TimeDelta::FromHours(1));
 
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(reconcilor->AreAllRefreshTokensChecked());
   ASSERT_FALSE(reconcilor->is_reconcile_started_);
 }
 
-
 TEST_F(AccountReconcilorTest, StartReconcileAddToCookie) {
   signin_manager()->SetAuthenticatedUsername("user@gmail.com");
   token_service()->UpdateCredentials("user@gmail.com", "refresh_token");
   token_service()->UpdateCredentials("other@gmail.com", "refresh_token");
 
   EXPECT_CALL(*GetMockReconcilor(), PerformMergeAction("other@gmail.com"));
 
   SetFakeResponse(GaiaUrls::GetInstance()->list_accounts_url().spec(),
       "[\"f\", [[\"b\", 0, \"n\", \"user@gmail.com\", \"p\", 0, 0, 0, 0, 1]]]",
       net::HTTP_OK, net::URLRequestStatus::SUCCESS);
@@ skipping 122 matching lines @@
   token_service()->IssueAllTokensForAccount("user@gmail.com", "access_token",
       base::Time::Now() + base::TimeDelta::FromHours(1));
   token_service()->IssueAllTokensForAccount("other@gmail.com", "access_token",
       base::Time::Now() + base::TimeDelta::FromHours(1));
 
   base::RunLoop().RunUntilIdle();
   SimulateMergeSessionCompleted(reconcilor, "user@gmail.com",
                                 GoogleServiceAuthError::AuthErrorNone());
   ASSERT_FALSE(reconcilor->is_reconcile_started_);
 }