Change RenderViewHostTestHarness to create BrowserContext after thread startup

chrome/browser/ui/sync/one_click_signin_helper_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 "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/signin/fake_signin_manager.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_names_io_thread.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/browser/sync/test_profile_sync_service.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/password_form.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/mock_render_process_host.h"
-#include "content/public/test/test_renderer_host.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::Return;
 
 namespace {
@@ skipping 144 matching lines @@
    bool first_setup_in_progress_;
 };
 
 static BrowserContextKeyedService* BuildSigninManagerMock(
     content::BrowserContext* profile) {
   return new SigninManagerMock(static_cast<Profile*>(profile));
 }
 
 }  // namespace
 
-class OneClickSigninHelperTest : public content::RenderViewHostTestHarness {
+class OneClickSigninHelperTest : public ChromeRenderViewHostTestHarness {
  public:
   OneClickSigninHelperTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   // Creates the sign-in manager for tests.  If |use_incognito| is true then
   // a WebContents for an incognito profile is created.  If |username| is
   // is not empty, the profile of the mock WebContents will be connected to
   // the given account.
   void CreateSigninManager(bool use_incognito, const std::string& username);
 
   // Set the ID of the signin process that the test will assume to be the
   // only process allowed to sign the user in to Chrome.
   void SetTrustedSigninProcessID(int id);
 
   void AddEmailToOneClickRejectedList(const std::string& email);
   void EnableOneClick(bool enable);
   void AllowSigninCookies(bool enable);
   void SetAllowedUsernamePattern(const std::string& pattern);
   ProfileSyncServiceMock* CreateProfileSyncServiceMock();
   void SubmitGAIAPassword(OneClickSigninHelper* helper);
   OneClickSigninHelper* SetupHelperForSignin();
 
   SigninManagerMock* signin_manager_;
 
  protected:
-  TestingProfile* profile_;
   GoogleServiceAuthError no_error_;
 
  private:
   // The ID of the signin process the test will assume to be trusted.
   // By default, set to the test RenderProcessHost's process ID, but
   // overridden by SetTrustedSigninProcessID.
   int trusted_signin_process_id_;
 
   DISALLOW_COPY_AND_ASSIGN(OneClickSigninHelperTest);
 };
 
 OneClickSigninHelperTest::OneClickSigninHelperTest()
-    : profile_(NULL),
-      no_error_(GoogleServiceAuthError::NONE),
+    : no_error_(GoogleServiceAuthError::NONE),
       trusted_signin_process_id_(-1) {
 }
 
 void OneClickSigninHelperTest::SetUp() {
   SyncPromoUI::ForceWebBasedSigninFlowForTesting(true);
-  profile_ = new TestingProfile();
-  browser_context_.reset(profile_);
   content::RenderViewHostTestHarness::SetUp();
   SetTrustedSigninProcessID(process()->GetID());
 }
 
 void OneClickSigninHelperTest::TearDown() {
   SyncPromoUI::ForceWebBasedSigninFlowForTesting(false);
   content::RenderViewHostTestHarness::TearDown();
 }
 
 void OneClickSigninHelperTest::SetTrustedSigninProcessID(int id) {
   trusted_signin_process_id_ = id;
 }
 
 void OneClickSigninHelperTest::CreateSigninManager(
     bool use_incognito,
     const std::string& username) {
-  profile_->set_incognito(use_incognito);
+  profile()->set_incognito(use_incognito);
   signin_manager_ = static_cast<SigninManagerMock*>(
       SigninManagerFactory::GetInstance()->SetTestingFactoryAndUse(
-          profile_, BuildSigninManagerMock));
+          profile(), BuildSigninManagerMock));
   if (signin_manager_)
     signin_manager_->SetSigninProcess(trusted_signin_process_id_);
 
   if (!username.empty()) {
     ASSERT_TRUE(signin_manager_);
     signin_manager_->SetAuthenticatedUsername(username);
   }
 }
 
 void OneClickSigninHelperTest::EnableOneClick(bool enable) {
-  PrefService* pref_service = Profile::FromBrowserContext(
-      browser_context_.get())->GetPrefs();
+  PrefService* pref_service = profile()->GetPrefs();
   pref_service->SetBoolean(prefs::kReverseAutologinEnabled, enable);
 }
 
 void OneClickSigninHelperTest::AddEmailToOneClickRejectedList(
     const std::string& email) {
-  PrefService* pref_service = Profile::FromBrowserContext(
-      browser_context_.get())->GetPrefs();
+  PrefService* pref_service = profile()->GetPrefs();
   ListPrefUpdate updater(pref_service,
                          prefs::kReverseAutologinRejectedEmailList);
   updater->AppendIfNotPresent(new base::StringValue(email));
 }
 
 void OneClickSigninHelperTest::AllowSigninCookies(bool enable) {
-  CookieSettings* cookie_settings = CookieSettings::Factory::GetForProfile(
-      Profile::FromBrowserContext(browser_context_.get())).get();
+  CookieSettings* cookie_settings =
+      CookieSettings::Factory::GetForProfile(profile()).get();
   cookie_settings->SetDefaultCookieSetting(enable ? CONTENT_SETTING_ALLOW
                                                   : CONTENT_SETTING_BLOCK);
 }
 
 void OneClickSigninHelperTest::SetAllowedUsernamePattern(
     const std::string& pattern) {
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetString(prefs::kGoogleServicesUsernamePattern, pattern);
 }
 
 ProfileSyncServiceMock*
 OneClickSigninHelperTest::CreateProfileSyncServiceMock() {
   ProfileSyncServiceMock* sync_service = static_cast<ProfileSyncServiceMock*>(
       ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-          profile_,
+          profile(),
           ProfileSyncServiceMock::BuildMockProfileSyncService));
   EXPECT_CALL(*sync_service, SetSetupInProgress(true));
   EXPECT_CALL(*sync_service, AddObserver(_)).Times(AtLeast(1));
   EXPECT_CALL(*sync_service, FirstSetupInProgress()).WillRepeatedly(
       Return(false));
   EXPECT_CALL(*sync_service, sync_initialized()).WillRepeatedly(Return(true));
   EXPECT_CALL(*sync_service, RemoveObserver(_)).Times(AtLeast(1));
   EXPECT_CALL(*sync_service, GetAuthError()).
       WillRepeatedly(::testing::ReturnRef(no_error_));
   EXPECT_CALL(*sync_service, sync_initialized()).WillRepeatedly(Return(false));
@@ skipping 34 matching lines @@
       valid_gaia_url_("https://accounts.google.com/") {
 }
 
 void OneClickSigninHelperIOTest::SetUp() {
   OneClickSigninHelperTest::SetUp();
   ASSERT_TRUE(testing_profile_manager_.SetUp());
 }
 
 TestProfileIOData* OneClickSigninHelperIOTest::CreateTestProfileIOData(
     bool is_incognito) {
-  PrefService* pref_service = profile_->GetPrefs();
+  PrefService* pref_service = profile()->GetPrefs();
   PrefService* local_state = g_browser_process->local_state();
   CookieSettings* cookie_settings =
-      CookieSettings::Factory::GetForProfile(profile_).get();
+      CookieSettings::Factory::GetForProfile(profile()).get();
   TestProfileIOData* io_data = new TestProfileIOData(
       is_incognito, pref_service, local_state, cookie_settings);
   io_data->set_reverse_autologin_pending_email("user@gmail.com");
   return io_data;
 }
 
 TEST_F(OneClickSigninHelperTest, CanOfferNoContents) {
   std::string error_message;
   EXPECT_FALSE(OneClickSigninHelper::CanOffer(
       NULL, OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY,
@@ skipping 221 matching lines @@
 
   EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)).
         WillRepeatedly(Return(true));
 
   EnableOneClick(true);
   EXPECT_TRUE(OneClickSigninHelper::CanOffer(
       web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL,
       "user@gmail.com", NULL));
 
   // Simulate a policy disabling signin by writing kSigninAllowed directly.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSigninAllowed, base::Value::CreateBooleanValue(false));
 
   EXPECT_FALSE(OneClickSigninHelper::CanOffer(
       web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL,
       "user@gmail.com", NULL));
 
   // Reset the preference value to true.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSigninAllowed, base::Value::CreateBooleanValue(true));
 
   // Simulate a policy disabling sync by writing kSyncManaged directly.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSyncManaged, base::Value::CreateBooleanValue(true));
 
   // Should still offer even if sync is disabled by policy.
   EXPECT_TRUE(OneClickSigninHelper::CanOffer(
       web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL,
       "user@gmail.com", NULL));
 }
 
 // Should not crash if a helper instance is not associated with an incognito
 // web contents.
@@ skipping 120 matching lines @@
 
 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadDisabled) {
   EnableOneClick(false);
   scoped_ptr<TestProfileIOData> io_data(CreateTestProfileIOData(false));
   EXPECT_EQ(OneClickSigninHelper::DONT_OFFER,
             OneClickSigninHelper::CanOfferOnIOThreadImpl(
                 valid_gaia_url_, std::string(), &request_, io_data.get()));
 }
 
 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadSignedIn) {
-  PrefService* pref_service = profile_->GetPrefs();
+  PrefService* pref_service = profile()->GetPrefs();
   pref_service->SetString(prefs::kGoogleServicesUsername, "user@gmail.com");
 
   scoped_ptr<TestProfileIOData> io_data(CreateTestProfileIOData(false));
   EXPECT_EQ(OneClickSigninHelper::DONT_OFFER,
             OneClickSigninHelper::CanOfferOnIOThreadImpl(
                 valid_gaia_url_, std::string(), &request_, io_data.get()));
 }
 
 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadEmailNotAllowed) {
   SetAllowedUsernamePattern("*@example.com");
@@ skipping 33 matching lines @@
 }
 
 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadDisabledByPolicy) {
   scoped_ptr<TestProfileIOData> io_data(CreateTestProfileIOData(false));
   EXPECT_EQ(OneClickSigninHelper::CAN_OFFER,
             OneClickSigninHelper::CanOfferOnIOThreadImpl(
                 valid_gaia_url_, std::string(), &request_, io_data.get()));
 
   // Simulate a policy disabling signin by writing kSigninAllowed directly.
   // We should not offer to sign in the browser.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSigninAllowed, base::Value::CreateBooleanValue(false));
   EXPECT_EQ(OneClickSigninHelper::DONT_OFFER,
             OneClickSigninHelper::CanOfferOnIOThreadImpl(
                 valid_gaia_url_, std::string(), &request_, io_data.get()));
 
   // Reset the preference.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSigninAllowed, base::Value::CreateBooleanValue(true));
 
   // Simulate a policy disabling sync by writing kSyncManaged directly.
   // We should still offer to sign in the browser.
-  profile_->GetTestingPrefService()->SetManagedPref(
+  profile()->GetTestingPrefService()->SetManagedPref(
       prefs::kSyncManaged, base::Value::CreateBooleanValue(true));
   EXPECT_EQ(OneClickSigninHelper::CAN_OFFER,
             OneClickSigninHelper::CanOfferOnIOThreadImpl(
                 valid_gaia_url_, std::string(), &request_, io_data.get()));
 }