| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/prefs/pref_service.h" | |
| 6 #include "base/prefs/scoped_user_pref_update.h" | |
| 7 #include "base/run_loop.h" | |
| 8 #include "base/strings/utf_string_conversions.h" | |
| 9 #include "base/values.h" | |
| 10 #include "chrome/browser/chrome_notification_types.h" | |
| 11 #include "chrome/browser/content_settings/cookie_settings.h" | |
| 12 #include "chrome/browser/custom_handlers/protocol_handler_registry.h" | |
| 13 #include "chrome/browser/profiles/profile.h" | |
| 14 #include "chrome/browser/profiles/profile_info_cache.h" | |
| 15 #include "chrome/browser/profiles/profile_io_data.h" | |
| 16 #include "chrome/browser/profiles/profile_manager.h" | |
| 17 #include "chrome/browser/signin/chrome_signin_client.h" | |
| 18 #include "chrome/browser/signin/chrome_signin_client_factory.h" | |
| 19 #include "chrome/browser/signin/fake_profile_oauth2_token_service.h" | |
| 20 #include "chrome/browser/signin/fake_profile_oauth2_token_service_builder.h" | |
| 21 #include "chrome/browser/signin/fake_signin_manager.h" | |
| 22 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" | |
| 23 #include "chrome/browser/signin/signin_manager_factory.h" | |
| 24 #include "chrome/browser/signin/signin_names_io_thread.h" | |
| 25 #include "chrome/browser/signin/signin_promo.h" | |
| 26 #include "chrome/browser/sync/profile_sync_components_factory_mock.h" | |
| 27 #include "chrome/browser/sync/profile_sync_service_factory.h" | |
| 28 #include "chrome/browser/sync/test_profile_sync_service.h" | |
| 29 #include "chrome/browser/ui/sync/one_click_signin_helper.h" | |
| 30 #include "chrome/browser/ui/webui/signin/login_ui_service.h" | |
| 31 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h" | |
| 32 #include "chrome/common/pref_names.h" | |
| 33 #include "chrome/grit/chromium_strings.h" | |
| 34 #include "chrome/grit/generated_resources.h" | |
| 35 #include "chrome/test/base/chrome_render_view_host_test_harness.h" | |
| 36 #include "chrome/test/base/testing_browser_process.h" | |
| 37 #include "chrome/test/base/testing_pref_service_syncable.h" | |
| 38 #include "chrome/test/base/testing_profile.h" | |
| 39 #include "chrome/test/base/testing_profile_manager.h" | |
| 40 #include "components/autofill/core/common/password_form.h" | |
| 41 #include "components/signin/core/browser/profile_oauth2_token_service.h" | |
| 42 #include "components/signin/core/browser/signin_manager.h" | |
| 43 #include "components/sync_driver/pref_names.h" | |
| 44 #include "content/public/browser/browser_context.h" | |
| 45 #include "content/public/browser/navigation_details.h" | |
| 46 #include "content/public/browser/navigation_entry.h" | |
| 47 #include "content/public/browser/web_contents.h" | |
| 48 #include "content/public/browser/web_contents_delegate.h" | |
| 49 #include "content/public/common/frame_navigate_params.h" | |
| 50 #include "content/public/common/url_constants.h" | |
| 51 #include "content/public/test/mock_render_process_host.h" | |
| 52 #include "testing/gmock/include/gmock/gmock.h" | |
| 53 #include "testing/gtest/include/gtest/gtest.h" | |
| 54 #include "ui/base/l10n/l10n_util.h" | |
| 55 | |
| 56 using ::testing::_; | |
| 57 using ::testing::AtLeast; | |
| 58 using ::testing::Return; | |
| 59 | |
| 60 namespace { | |
| 61 | |
| 62 // Used to confirm OneClickSigninHelper does not trigger redirect when there is | |
| 63 // a pending navigation. | |
| 64 class MockWebContentsDelegate : public content::WebContentsDelegate { | |
| 65 public: | |
| 66 MOCK_METHOD2(OpenURLFromTab, | |
| 67 content::WebContents*(content::WebContents* source, | |
| 68 const content::OpenURLParams& params)); | |
| 69 }; | |
| 70 | |
| 71 class SigninManagerMock : public FakeSigninManager { | |
| 72 public: | |
| 73 explicit SigninManagerMock(Profile* profile) : FakeSigninManager(profile) { | |
| 74 Initialize(NULL); | |
| 75 } | |
| 76 MOCK_CONST_METHOD1(IsAllowedUsername, bool(const std::string& username)); | |
| 77 }; | |
| 78 | |
| 79 static KeyedService* BuildSigninManagerMock(content::BrowserContext* profile) { | |
| 80 return new SigninManagerMock(static_cast<Profile*>(profile)); | |
| 81 } | |
| 82 | |
| 83 class TestProfileIOData : public ProfileIOData { | |
| 84 public: | |
| 85 TestProfileIOData(Profile::ProfileType profile_type, | |
| 86 PrefService* pref_service, PrefService* local_state, | |
| 87 CookieSettings* cookie_settings) | |
| 88 : ProfileIOData(profile_type) { | |
| 89 // Initialize the IO members required for these tests, but keep them on | |
| 90 // this thread since we don't use a background thread here. | |
| 91 google_services_username()->Init(prefs::kGoogleServicesUsername, | |
| 92 pref_service); | |
| 93 reverse_autologin_enabled()->Init(prefs::kReverseAutologinEnabled, | |
| 94 pref_service); | |
| 95 one_click_signin_rejected_email_list()->Init( | |
| 96 prefs::kReverseAutologinRejectedEmailList, pref_service); | |
| 97 | |
| 98 google_services_username_pattern()->Init( | |
| 99 prefs::kGoogleServicesUsernamePattern, local_state); | |
| 100 | |
| 101 sync_disabled()->Init(sync_driver::prefs::kSyncManaged, pref_service); | |
| 102 | |
| 103 signin_allowed()->Init(prefs::kSigninAllowed, pref_service); | |
| 104 | |
| 105 set_signin_names_for_testing(new SigninNamesOnIOThread()); | |
| 106 SetCookieSettingsForTesting(cookie_settings); | |
| 107 } | |
| 108 | |
| 109 ~TestProfileIOData() override { | |
| 110 signin_names()->ReleaseResourcesOnUIThread(); | |
| 111 } | |
| 112 | |
| 113 // ProfileIOData overrides: | |
| 114 void InitializeInternal( | |
| 115 scoped_ptr<ChromeNetworkDelegate> chrome_network_delegate, | |
| 116 ProfileParams* profile_params, | |
| 117 content::ProtocolHandlerMap* protocol_handlers, | |
| 118 content::URLRequestInterceptorScopedVector | |
| 119 request_interceptors) const override { | |
| 120 NOTREACHED(); | |
| 121 } | |
| 122 void InitializeExtensionsRequestContext( | |
| 123 ProfileParams* profile_params) const override { | |
| 124 NOTREACHED(); | |
| 125 } | |
| 126 net::URLRequestContext* InitializeAppRequestContext( | |
| 127 net::URLRequestContext* main_context, | |
| 128 const StoragePartitionDescriptor& details, | |
| 129 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> | |
| 130 protocol_handler_interceptor, | |
| 131 content::ProtocolHandlerMap* protocol_handlers, | |
| 132 content::URLRequestInterceptorScopedVector request_interceptors) | |
| 133 const override { | |
| 134 NOTREACHED(); | |
| 135 return NULL; | |
| 136 } | |
| 137 net::URLRequestContext* InitializeMediaRequestContext( | |
| 138 net::URLRequestContext* original_context, | |
| 139 const StoragePartitionDescriptor& details) const override { | |
| 140 NOTREACHED(); | |
| 141 return NULL; | |
| 142 } | |
| 143 net::URLRequestContext* AcquireMediaRequestContext() const override { | |
| 144 NOTREACHED(); | |
| 145 return NULL; | |
| 146 } | |
| 147 net::URLRequestContext* AcquireIsolatedAppRequestContext( | |
| 148 net::URLRequestContext* main_context, | |
| 149 const StoragePartitionDescriptor& partition_descriptor, | |
| 150 scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> | |
| 151 protocol_handler_interceptor, | |
| 152 content::ProtocolHandlerMap* protocol_handlers, | |
| 153 content::URLRequestInterceptorScopedVector request_interceptors) | |
| 154 const override { | |
| 155 NOTREACHED(); | |
| 156 return NULL; | |
| 157 } | |
| 158 net::URLRequestContext* AcquireIsolatedMediaRequestContext( | |
| 159 net::URLRequestContext* app_context, | |
| 160 const StoragePartitionDescriptor& partition_descriptor) const override { | |
| 161 NOTREACHED(); | |
| 162 return NULL; | |
| 163 } | |
| 164 }; | |
| 165 | |
| 166 class TestURLRequest : public base::SupportsUserData { | |
| 167 public: | |
| 168 TestURLRequest() {} | |
| 169 ~TestURLRequest() override {} | |
| 170 }; | |
| 171 | |
| 172 class OneClickTestProfileSyncService : public TestProfileSyncService { | |
| 173 public: | |
| 174 ~OneClickTestProfileSyncService() override {} | |
| 175 | |
| 176 // Helper routine to be used in conjunction with | |
| 177 // BrowserContextKeyedServiceFactory::SetTestingFactory(). | |
| 178 static KeyedService* Build(content::BrowserContext* profile) { | |
| 179 return new OneClickTestProfileSyncService(static_cast<Profile*>(profile)); | |
| 180 } | |
| 181 | |
| 182 // Need to control this for certain tests. | |
| 183 bool FirstSetupInProgress() const override { | |
| 184 return first_setup_in_progress_; | |
| 185 } | |
| 186 | |
| 187 bool SyncActive() const override { return sync_active_; } | |
| 188 | |
| 189 // Controls return value of FirstSetupInProgress. Because some bits | |
| 190 // of UI depend on that value, it's useful to control it separately | |
| 191 // from the internal work and components that are triggered (such as | |
| 192 // ReconfigureDataTypeManager) to facilitate unit tests. | |
| 193 void set_first_setup_in_progress(bool in_progress) { | |
| 194 first_setup_in_progress_ = in_progress; | |
| 195 } | |
| 196 | |
| 197 void set_sync_active(bool active) { | |
| 198 sync_active_ = active; | |
| 199 } | |
| 200 | |
| 201 private: | |
| 202 explicit OneClickTestProfileSyncService(Profile* profile) | |
| 203 : TestProfileSyncService( | |
| 204 scoped_ptr<ProfileSyncComponentsFactory>( | |
| 205 new ProfileSyncComponentsFactoryMock()), | |
| 206 profile, | |
| 207 SigninManagerFactory::GetForProfile(profile), | |
| 208 ProfileOAuth2TokenServiceFactory::GetForProfile(profile), | |
| 209 browser_sync::MANUAL_START), | |
| 210 first_setup_in_progress_(false), | |
| 211 sync_active_(false) {} | |
| 212 | |
| 213 bool first_setup_in_progress_; | |
| 214 bool sync_active_; | |
| 215 }; | |
| 216 | |
| 217 } // namespace | |
| 218 | |
| 219 class OneClickSigninHelperTest : public ChromeRenderViewHostTestHarness { | |
| 220 public: | |
| 221 OneClickSigninHelperTest(); | |
| 222 | |
| 223 void SetUp() override; | |
| 224 void TearDown() override; | |
| 225 | |
| 226 // Sets up the sign-in manager for tests. If |username| is | |
| 227 // is not empty, the profile of the mock WebContents will be connected to | |
| 228 // the given account. | |
| 229 void SetUpSigninManager(const std::string& username); | |
| 230 | |
| 231 // Set the ID of the signin process that the test will assume to be the | |
| 232 // only process allowed to sign the user in to Chrome. | |
| 233 void SetTrustedSigninProcessID(int id); | |
| 234 | |
| 235 void AddEmailToOneClickRejectedList(const std::string& email); | |
| 236 void EnableOneClick(bool enable); | |
| 237 void AllowSigninCookies(bool enable); | |
| 238 void SetAllowedUsernamePattern(const std::string& pattern); | |
| 239 void SubmitGAIAPassword(OneClickSigninHelper* helper); | |
| 240 | |
| 241 SigninManagerMock* signin_manager_; | |
| 242 FakeProfileOAuth2TokenService* fake_oauth2_token_service_; | |
| 243 | |
| 244 protected: | |
| 245 GoogleServiceAuthError no_error_; | |
| 246 | |
| 247 private: | |
| 248 // ChromeRenderViewHostTestHarness overrides: | |
| 249 content::BrowserContext* CreateBrowserContext() override; | |
| 250 | |
| 251 // The ID of the signin process the test will assume to be trusted. | |
| 252 // By default, set to the test RenderProcessHost's process ID, but | |
| 253 // overridden by SetTrustedSigninProcessID. | |
| 254 int trusted_signin_process_id_; | |
| 255 | |
| 256 DISALLOW_COPY_AND_ASSIGN(OneClickSigninHelperTest); | |
| 257 }; | |
| 258 | |
| 259 OneClickSigninHelperTest::OneClickSigninHelperTest() | |
| 260 : signin_manager_(NULL), | |
| 261 fake_oauth2_token_service_(NULL), | |
| 262 no_error_(GoogleServiceAuthError::NONE), | |
| 263 trusted_signin_process_id_(-1) { | |
| 264 } | |
| 265 | |
| 266 void OneClickSigninHelperTest::SetUp() { | |
| 267 signin::ForceWebBasedSigninFlowForTesting(true); | |
| 268 content::RenderViewHostTestHarness::SetUp(); | |
| 269 SetTrustedSigninProcessID(process()->GetID()); | |
| 270 } | |
| 271 | |
| 272 void OneClickSigninHelperTest::TearDown() { | |
| 273 signin::ForceWebBasedSigninFlowForTesting(false); | |
| 274 content::RenderViewHostTestHarness::TearDown(); | |
| 275 } | |
| 276 | |
| 277 void OneClickSigninHelperTest::SetTrustedSigninProcessID(int id) { | |
| 278 trusted_signin_process_id_ = id; | |
| 279 } | |
| 280 | |
| 281 void OneClickSigninHelperTest::SetUpSigninManager(const std::string& username) { | |
| 282 SigninClient* signin_client = | |
| 283 ChromeSigninClientFactory::GetForProfile(profile()); | |
| 284 if (signin_client) | |
| 285 signin_client->SetSigninProcess(trusted_signin_process_id_); | |
| 286 | |
| 287 signin_manager_ = static_cast<SigninManagerMock*>( | |
| 288 SigninManagerFactory::GetForProfile(profile())); | |
| 289 if (!username.empty()) { | |
| 290 ASSERT_TRUE(signin_manager_); | |
| 291 signin_manager_->SetAuthenticatedUsername(username); | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 void OneClickSigninHelperTest::EnableOneClick(bool enable) { | |
| 296 PrefService* pref_service = profile()->GetPrefs(); | |
| 297 pref_service->SetBoolean(prefs::kReverseAutologinEnabled, enable); | |
| 298 } | |
| 299 | |
| 300 void OneClickSigninHelperTest::AddEmailToOneClickRejectedList( | |
| 301 const std::string& email) { | |
| 302 PrefService* pref_service = profile()->GetPrefs(); | |
| 303 ListPrefUpdate updater(pref_service, | |
| 304 prefs::kReverseAutologinRejectedEmailList); | |
| 305 updater->AppendIfNotPresent(new base::StringValue(email)); | |
| 306 } | |
| 307 | |
| 308 void OneClickSigninHelperTest::AllowSigninCookies(bool enable) { | |
| 309 CookieSettings* cookie_settings = | |
| 310 CookieSettings::Factory::GetForProfile(profile()).get(); | |
| 311 cookie_settings->SetDefaultCookieSetting(enable ? CONTENT_SETTING_ALLOW | |
| 312 : CONTENT_SETTING_BLOCK); | |
| 313 } | |
| 314 | |
| 315 void OneClickSigninHelperTest::SetAllowedUsernamePattern( | |
| 316 const std::string& pattern) { | |
| 317 PrefService* local_state = g_browser_process->local_state(); | |
| 318 local_state->SetString(prefs::kGoogleServicesUsernamePattern, pattern); | |
| 319 } | |
| 320 | |
| 321 void OneClickSigninHelperTest::SubmitGAIAPassword( | |
| 322 OneClickSigninHelper* helper) { | |
| 323 autofill::PasswordForm password_form; | |
| 324 password_form.origin = GURL("https://accounts.google.com"); | |
| 325 password_form.signon_realm = "https://accounts.google.com"; | |
| 326 password_form.password_value = base::UTF8ToUTF16("password"); | |
| 327 helper->PasswordSubmitted(password_form); | |
| 328 } | |
| 329 | |
| 330 content::BrowserContext* OneClickSigninHelperTest::CreateBrowserContext() { | |
| 331 TestingProfile::Builder builder; | |
| 332 builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(), | |
| 333 BuildFakeProfileOAuth2TokenService); | |
| 334 builder.AddTestingFactory(SigninManagerFactory::GetInstance(), | |
| 335 BuildSigninManagerMock); | |
| 336 scoped_ptr<TestingProfile> profile = builder.Build(); | |
| 337 | |
| 338 fake_oauth2_token_service_ = | |
| 339 static_cast<FakeProfileOAuth2TokenService*>( | |
| 340 ProfileOAuth2TokenServiceFactory::GetForProfile(profile.get())); | |
| 341 | |
| 342 return profile.release(); | |
| 343 } | |
| 344 | |
| 345 class OneClickSigninHelperIOTest : public OneClickSigninHelperTest { | |
| 346 public: | |
| 347 OneClickSigninHelperIOTest(); | |
| 348 | |
| 349 void SetUp() override; | |
| 350 | |
| 351 TestProfileIOData* CreateTestProfileIOData(Profile::ProfileType profile_type); | |
| 352 | |
| 353 protected: | |
| 354 TestingProfileManager testing_profile_manager_; | |
| 355 TestURLRequest request_; | |
| 356 const GURL valid_gaia_url_; | |
| 357 | |
| 358 private: | |
| 359 DISALLOW_COPY_AND_ASSIGN(OneClickSigninHelperIOTest); | |
| 360 }; | |
| 361 | |
| 362 OneClickSigninHelperIOTest::OneClickSigninHelperIOTest() | |
| 363 : testing_profile_manager_( | |
| 364 TestingBrowserProcess::GetGlobal()), | |
| 365 valid_gaia_url_("https://accounts.google.com/") { | |
| 366 } | |
| 367 | |
| 368 void OneClickSigninHelperIOTest::SetUp() { | |
| 369 OneClickSigninHelperTest::SetUp(); | |
| 370 ASSERT_TRUE(testing_profile_manager_.SetUp()); | |
| 371 } | |
| 372 | |
| 373 TestProfileIOData* OneClickSigninHelperIOTest::CreateTestProfileIOData( | |
| 374 Profile::ProfileType profile_type) { | |
| 375 PrefService* pref_service = profile()->GetPrefs(); | |
| 376 PrefService* local_state = g_browser_process->local_state(); | |
| 377 CookieSettings* cookie_settings = | |
| 378 CookieSettings::Factory::GetForProfile(profile()).get(); | |
| 379 TestProfileIOData* io_data = new TestProfileIOData( | |
| 380 profile_type, pref_service, local_state, cookie_settings); | |
| 381 io_data->set_reverse_autologin_pending_email("user@gmail.com"); | |
| 382 return io_data; | |
| 383 } | |
| 384 | |
| 385 class OneClickSigninHelperIncognitoTest : public OneClickSigninHelperTest { | |
| 386 protected: | |
| 387 // content::RenderViewHostTestHarness. | |
| 388 content::BrowserContext* CreateBrowserContext() override; | |
| 389 }; | |
| 390 | |
| 391 content::BrowserContext* | |
| 392 OneClickSigninHelperIncognitoTest::CreateBrowserContext() { | |
| 393 // Simulate an incognito profile to run this test. RenderViewHostTestHarness | |
| 394 // takes ownership of the return value, so it can't be a "proper" incognito | |
| 395 // profile, since they are owned by their parent, non-incognito profile. | |
| 396 scoped_ptr<TestingProfile> profile = TestingProfile::Builder().Build(); | |
| 397 profile->ForceIncognito(true); | |
| 398 return profile.release(); | |
| 399 } | |
| 400 | |
| 401 TEST_F(OneClickSigninHelperTest, CanOfferNoContents) { | |
| 402 std::string error_message; | |
| 403 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 404 NULL, OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 405 "user@gmail.com", &error_message)); | |
| 406 EXPECT_EQ("", error_message); | |
| 407 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 408 NULL, OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 409 "user@gmail.com", &error_message)); | |
| 410 EXPECT_EQ("", error_message); | |
| 411 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 412 NULL, | |
| 413 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 414 std::string(), | |
| 415 &error_message)); | |
| 416 EXPECT_EQ("", error_message); | |
| 417 } | |
| 418 | |
| 419 TEST_F(OneClickSigninHelperTest, CanOffer) { | |
| 420 SetUpSigninManager(std::string()); | |
| 421 | |
| 422 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 423 WillRepeatedly(Return(true)); | |
| 424 | |
| 425 EnableOneClick(true); | |
| 426 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 427 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 428 "user@gmail.com", NULL)); | |
| 429 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 430 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 431 "user@gmail.com", NULL)); | |
| 432 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 433 web_contents(), | |
| 434 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 435 std::string(), | |
| 436 NULL)); | |
| 437 | |
| 438 EnableOneClick(false); | |
| 439 | |
| 440 std::string error_message; | |
| 441 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 442 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 443 "user@gmail.com", &error_message)); | |
| 444 EXPECT_EQ("", error_message); | |
| 445 | |
| 446 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 447 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 448 "user@gmail.com", &error_message)); | |
| 449 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 450 web_contents(), | |
| 451 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 452 std::string(), | |
| 453 &error_message)); | |
| 454 EXPECT_EQ("", error_message); | |
| 455 } | |
| 456 | |
| 457 TEST_F(OneClickSigninHelperTest, CanOfferFirstSetup) { | |
| 458 SetUpSigninManager(std::string()); | |
| 459 | |
| 460 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 461 WillRepeatedly(Return(true)); | |
| 462 | |
| 463 // Invoke OneClickTestProfileSyncService factory function and grab result. | |
| 464 OneClickTestProfileSyncService* sync = | |
| 465 static_cast<OneClickTestProfileSyncService*>( | |
| 466 ProfileSyncServiceFactory::GetInstance()->SetTestingFactoryAndUse( | |
| 467 profile(), OneClickTestProfileSyncService::Build)); | |
| 468 sync->set_sync_active(false); | |
| 469 sync->Initialize(); | |
| 470 sync->set_sync_active(true); | |
| 471 sync->set_first_setup_in_progress(true); | |
| 472 | |
| 473 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 474 web_contents(), | |
| 475 OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 476 "foo@gmail.com", NULL)); | |
| 477 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 478 web_contents(), | |
| 479 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 480 "foo@gmail.com", NULL)); | |
| 481 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 482 web_contents(), | |
| 483 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 484 std::string(), | |
| 485 NULL)); | |
| 486 } | |
| 487 | |
| 488 TEST_F(OneClickSigninHelperTest, CanOfferProfileConnected) { | |
| 489 SetUpSigninManager("foo@gmail.com"); | |
| 490 | |
| 491 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 492 WillRepeatedly(Return(true)); | |
| 493 | |
| 494 std::string error_message; | |
| 495 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 496 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 497 "foo@gmail.com", &error_message)); | |
| 498 EXPECT_EQ("", error_message); | |
| 499 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 500 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 501 "foo", &error_message)); | |
| 502 EXPECT_EQ("", error_message); | |
| 503 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 504 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 505 "user@gmail.com", &error_message)); | |
| 506 EXPECT_EQ(l10n_util::GetStringFUTF8(IDS_SYNC_WRONG_EMAIL, | |
| 507 base::UTF8ToUTF16("foo@gmail.com")), | |
| 508 error_message); | |
| 509 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 510 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 511 "foo@gmail.com", &error_message)); | |
| 512 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 513 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 514 "foo", &error_message)); | |
| 515 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 516 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 517 "user@gmail.com", &error_message)); | |
| 518 EXPECT_EQ(l10n_util::GetStringFUTF8(IDS_SYNC_WRONG_EMAIL, | |
| 519 base::UTF8ToUTF16("foo@gmail.com")), | |
| 520 error_message); | |
| 521 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 522 web_contents(), | |
| 523 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 524 std::string(), | |
| 525 &error_message)); | |
| 526 } | |
| 527 | |
| 528 TEST_F(OneClickSigninHelperTest, CanOfferUsernameNotAllowed) { | |
| 529 SetUpSigninManager(std::string()); | |
| 530 | |
| 531 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 532 WillRepeatedly(Return(false)); | |
| 533 | |
| 534 std::string error_message; | |
| 535 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 536 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 537 "foo@gmail.com", &error_message)); | |
| 538 EXPECT_EQ(l10n_util::GetStringUTF8(IDS_SYNC_LOGIN_NAME_PROHIBITED), | |
| 539 error_message); | |
| 540 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 541 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 542 "foo@gmail.com", &error_message)); | |
| 543 EXPECT_EQ(l10n_util::GetStringUTF8(IDS_SYNC_LOGIN_NAME_PROHIBITED), | |
| 544 error_message); | |
| 545 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 546 web_contents(), | |
| 547 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 548 std::string(), | |
| 549 &error_message)); | |
| 550 } | |
| 551 | |
| 552 TEST_F(OneClickSigninHelperTest, CanOfferWithRejectedEmail) { | |
| 553 SetUpSigninManager(std::string()); | |
| 554 | |
| 555 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 556 WillRepeatedly(Return(true)); | |
| 557 | |
| 558 AddEmailToOneClickRejectedList("foo@gmail.com"); | |
| 559 AddEmailToOneClickRejectedList("user@gmail.com"); | |
| 560 | |
| 561 std::string error_message; | |
| 562 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 563 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 564 "foo@gmail.com", &error_message)); | |
| 565 EXPECT_EQ("", error_message); | |
| 566 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 567 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 568 "user@gmail.com", &error_message)); | |
| 569 EXPECT_EQ("", error_message); | |
| 570 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 571 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 572 "foo@gmail.com", &error_message)); | |
| 573 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 574 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 575 "user@gmail.com", &error_message)); | |
| 576 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 577 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 578 "john@gmail.com", &error_message)); | |
| 579 } | |
| 580 | |
| 581 TEST_F(OneClickSigninHelperIncognitoTest, CanOfferIncognito) { | |
| 582 SetUpSigninManager(std::string()); | |
| 583 | |
| 584 std::string error_message; | |
| 585 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 586 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 587 "user@gmail.com", &error_message)); | |
| 588 EXPECT_EQ("", error_message); | |
| 589 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 590 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 591 "user@gmail.com", &error_message)); | |
| 592 EXPECT_EQ("", error_message); | |
| 593 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 594 web_contents(), | |
| 595 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 596 std::string(), | |
| 597 &error_message)); | |
| 598 EXPECT_EQ("", error_message); | |
| 599 } | |
| 600 | |
| 601 TEST_F(OneClickSigninHelperTest, CanOfferNoSigninCookies) { | |
| 602 SetUpSigninManager(std::string()); | |
| 603 AllowSigninCookies(false); | |
| 604 | |
| 605 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 606 WillRepeatedly(Return(true)); | |
| 607 | |
| 608 std::string error_message; | |
| 609 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 610 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 611 "user@gmail.com", &error_message)); | |
| 612 EXPECT_EQ("", error_message); | |
| 613 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 614 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 615 "user@gmail.com", &error_message)); | |
| 616 EXPECT_EQ("", error_message); | |
| 617 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 618 web_contents(), | |
| 619 OneClickSigninHelper::CAN_OFFER_FOR_INTERSTITAL_ONLY, | |
| 620 std::string(), | |
| 621 &error_message)); | |
| 622 EXPECT_EQ("", error_message); | |
| 623 } | |
| 624 | |
| 625 TEST_F(OneClickSigninHelperTest, CanOfferDisabledByPolicy) { | |
| 626 SetUpSigninManager(std::string()); | |
| 627 | |
| 628 EXPECT_CALL(*signin_manager_, IsAllowedUsername(_)). | |
| 629 WillRepeatedly(Return(true)); | |
| 630 | |
| 631 EnableOneClick(true); | |
| 632 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 633 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 634 "user@gmail.com", NULL)); | |
| 635 | |
| 636 // Simulate a policy disabling signin by writing kSigninAllowed directly. | |
| 637 profile()->GetTestingPrefService()->SetManagedPref( | |
| 638 prefs::kSigninAllowed, new base::FundamentalValue(false)); | |
| 639 | |
| 640 EXPECT_FALSE(OneClickSigninHelper::CanOffer( | |
| 641 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 642 "user@gmail.com", NULL)); | |
| 643 | |
| 644 // Reset the preference value to true. | |
| 645 profile()->GetTestingPrefService()->SetManagedPref( | |
| 646 prefs::kSigninAllowed, new base::FundamentalValue(true)); | |
| 647 | |
| 648 // Simulate a policy disabling sync by writing kSyncManaged directly. | |
| 649 profile()->GetTestingPrefService()->SetManagedPref( | |
| 650 sync_driver::prefs::kSyncManaged, new base::FundamentalValue(true)); | |
| 651 | |
| 652 // Should still offer even if sync is disabled by policy. | |
| 653 EXPECT_TRUE(OneClickSigninHelper::CanOffer( | |
| 654 web_contents(), OneClickSigninHelper::CAN_OFFER_FOR_ALL, | |
| 655 "user@gmail.com", NULL)); | |
| 656 } | |
| 657 | |
| 658 // Should not crash if a helper instance is not associated with an incognito | |
| 659 // web contents. | |
| 660 TEST_F(OneClickSigninHelperIncognitoTest, ShowInfoBarUIThreadIncognito) { | |
| 661 SetUpSigninManager(std::string()); | |
| 662 OneClickSigninHelper* helper = | |
| 663 OneClickSigninHelper::FromWebContents(web_contents()); | |
| 664 EXPECT_EQ(NULL, helper); | |
| 665 | |
| 666 OneClickSigninHelper::ShowInfoBarUIThread( | |
| 667 "session_index", "email", OneClickSigninHelper::AUTO_ACCEPT_ACCEPTED, | |
| 668 signin_metrics::SOURCE_UNKNOWN, GURL(), process()->GetID(), | |
| 669 rvh()->GetRoutingID()); | |
| 670 } | |
| 671 | |
| 672 // Checks that the state of OneClickSigninHelper is cleaned when there is a | |
| 673 // navigation away from the sign in flow that is not triggered by the | |
| 674 // web contents. | |
| 675 TEST_F(OneClickSigninHelperTest, CleanTransientStateOnNavigate) { | |
| 676 content::WebContents* contents = web_contents(); | |
| 677 | |
| 678 OneClickSigninHelper::CreateForWebContents(contents); | |
| 679 OneClickSigninHelper* helper = | |
| 680 OneClickSigninHelper::FromWebContents(contents); | |
| 681 helper->SetDoNotClearPendingEmailForTesting(); | |
| 682 helper->auto_accept_ = OneClickSigninHelper::AUTO_ACCEPT_EXPLICIT; | |
| 683 | |
| 684 content::LoadCommittedDetails details; | |
| 685 content::FrameNavigateParams params; | |
| 686 params.url = GURL("http://crbug.com"); | |
| 687 params.transition = ui::PAGE_TRANSITION_TYPED; | |
| 688 helper->DidNavigateMainFrame(details, params); | |
| 689 | |
| 690 EXPECT_EQ(OneClickSigninHelper::AUTO_ACCEPT_NONE, helper->auto_accept_); | |
| 691 } | |
| 692 | |
| 693 TEST_F(OneClickSigninHelperTest, NoRedirectToNTPWithPendingEntry) { | |
| 694 content::NavigationController& controller = web_contents()->GetController(); | |
| 695 EXPECT_FALSE(controller.GetPendingEntry()); | |
| 696 | |
| 697 const GURL fooWebUIURL("chrome://foo"); | |
| 698 controller.LoadURL(fooWebUIURL, content::Referrer(), | |
| 699 ui::PAGE_TRANSITION_TYPED, std::string()); | |
| 700 EXPECT_EQ(fooWebUIURL, controller.GetPendingEntry()->GetURL()); | |
| 701 | |
| 702 MockWebContentsDelegate delegate; | |
| 703 EXPECT_CALL(delegate, OpenURLFromTab(_, _)).Times(0); | |
| 704 web_contents()->SetDelegate(&delegate); | |
| 705 OneClickSigninHelper::RedirectToNtpOrAppsPage( | |
| 706 web_contents(), signin_metrics::SOURCE_UNKNOWN); | |
| 707 | |
| 708 EXPECT_EQ(fooWebUIURL, controller.GetPendingEntry()->GetURL()); | |
| 709 } | |
| 710 | |
| 711 // I/O thread tests | |
| 712 | |
| 713 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThread) { | |
| 714 scoped_ptr<TestProfileIOData> io_data( | |
| 715 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 716 EXPECT_EQ(OneClickSigninHelper::CAN_OFFER, | |
| 717 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 718 valid_gaia_url_, &request_, io_data.get())); | |
| 719 } | |
| 720 | |
| 721 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadIncognito) { | |
| 722 scoped_ptr<TestProfileIOData> io_data( | |
| 723 CreateTestProfileIOData(Profile::INCOGNITO_PROFILE)); | |
| 724 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 725 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 726 valid_gaia_url_, &request_, io_data.get())); | |
| 727 } | |
| 728 | |
| 729 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadNoIOData) { | |
| 730 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 731 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 732 valid_gaia_url_, &request_, NULL)); | |
| 733 } | |
| 734 | |
| 735 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadBadURL) { | |
| 736 scoped_ptr<TestProfileIOData> io_data( | |
| 737 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 738 EXPECT_EQ( | |
| 739 OneClickSigninHelper::IGNORE_REQUEST, | |
| 740 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 741 GURL("https://foo.com/"), &request_, io_data.get())); | |
| 742 EXPECT_EQ(OneClickSigninHelper::IGNORE_REQUEST, | |
| 743 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 744 GURL("http://accounts.google.com/"), | |
| 745 &request_, | |
| 746 io_data.get())); | |
| 747 } | |
| 748 | |
| 749 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadDisabled) { | |
| 750 EnableOneClick(false); | |
| 751 scoped_ptr<TestProfileIOData> io_data( | |
| 752 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 753 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 754 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 755 valid_gaia_url_, &request_, io_data.get())); | |
| 756 } | |
| 757 | |
| 758 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadSignedIn) { | |
| 759 PrefService* pref_service = profile()->GetPrefs(); | |
| 760 pref_service->SetString(prefs::kGoogleServicesUsername, "user@gmail.com"); | |
| 761 | |
| 762 scoped_ptr<TestProfileIOData> io_data( | |
| 763 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 764 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 765 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 766 valid_gaia_url_, &request_, io_data.get())); | |
| 767 } | |
| 768 | |
| 769 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadEmailNotAllowed) { | |
| 770 SetAllowedUsernamePattern("*@example.com"); | |
| 771 scoped_ptr<TestProfileIOData> io_data( | |
| 772 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 773 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 774 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 775 valid_gaia_url_, &request_, io_data.get())); | |
| 776 } | |
| 777 | |
| 778 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadEmailAlreadyUsed) { | |
| 779 ProfileInfoCache* cache = testing_profile_manager_.profile_info_cache(); | |
| 780 const base::FilePath& user_data_dir = cache->GetUserDataDir(); | |
| 781 cache->AddProfileToCache(user_data_dir.Append(FILE_PATH_LITERAL("user")), | |
| 782 base::UTF8ToUTF16("user"), | |
| 783 base::UTF8ToUTF16("user@gmail.com"), 0, | |
| 784 std::string()); | |
| 785 | |
| 786 scoped_ptr<TestProfileIOData> io_data( | |
| 787 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 788 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 789 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 790 valid_gaia_url_, &request_, io_data.get())); | |
| 791 } | |
| 792 | |
| 793 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadWithRejectedEmail) { | |
| 794 AddEmailToOneClickRejectedList("user@gmail.com"); | |
| 795 scoped_ptr<TestProfileIOData> io_data( | |
| 796 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 797 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 798 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 799 valid_gaia_url_, &request_, io_data.get())); | |
| 800 } | |
| 801 | |
| 802 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadNoSigninCookies) { | |
| 803 AllowSigninCookies(false); | |
| 804 scoped_ptr<TestProfileIOData> io_data( | |
| 805 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 806 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 807 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 808 valid_gaia_url_, &request_, io_data.get())); | |
| 809 } | |
| 810 | |
| 811 TEST_F(OneClickSigninHelperIOTest, CanOfferOnIOThreadDisabledByPolicy) { | |
| 812 scoped_ptr<TestProfileIOData> io_data( | |
| 813 CreateTestProfileIOData(Profile::REGULAR_PROFILE)); | |
| 814 EXPECT_EQ(OneClickSigninHelper::CAN_OFFER, | |
| 815 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 816 valid_gaia_url_, &request_, io_data.get())); | |
| 817 | |
| 818 // Simulate a policy disabling signin by writing kSigninAllowed directly. | |
| 819 // We should not offer to sign in the browser. | |
| 820 profile()->GetTestingPrefService()->SetManagedPref( | |
| 821 prefs::kSigninAllowed, new base::FundamentalValue(false)); | |
| 822 EXPECT_EQ(OneClickSigninHelper::DONT_OFFER, | |
| 823 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 824 valid_gaia_url_, &request_, io_data.get())); | |
| 825 | |
| 826 // Reset the preference. | |
| 827 profile()->GetTestingPrefService()->SetManagedPref( | |
| 828 prefs::kSigninAllowed, new base::FundamentalValue(true)); | |
| 829 | |
| 830 // Simulate a policy disabling sync by writing kSyncManaged directly. | |
| 831 // We should still offer to sign in the browser. | |
| 832 profile()->GetTestingPrefService()->SetManagedPref( | |
| 833 sync_driver::prefs::kSyncManaged, new base::FundamentalValue(true)); | |
| 834 EXPECT_EQ(OneClickSigninHelper::CAN_OFFER, | |
| 835 OneClickSigninHelper::CanOfferOnIOThreadImpl( | |
| 836 valid_gaia_url_, &request_, io_data.get())); | |
| 837 } | |
| 838 | |
| 839 | |
| 840 class MockStarterWrapper | |
| 841 : public testing::StrictMock<OneClickSigninHelper::SyncStarterWrapper> { | |
| 842 public: | |
| 843 MockStarterWrapper( | |
| 844 const OneClickSigninHelper::StartSyncArgs& args, | |
| 845 OneClickSigninSyncStarter::StartSyncMode start_mode); | |
| 846 | |
| 847 MOCK_METHOD1(DisplayErrorBubble, void(const std::string& error_message)); | |
| 848 MOCK_METHOD0(StartSigninOAuthHelper, void()); | |
| 849 MOCK_METHOD2(StartOneClickSigninSyncStarter, | |
| 850 void(const std::string& email, | |
| 851 const std::string& refresh_token)); | |
| 852 }; | |
| 853 | |
| 854 MockStarterWrapper::MockStarterWrapper( | |
| 855 const OneClickSigninHelper::StartSyncArgs& args, | |
| 856 OneClickSigninSyncStarter::StartSyncMode start_mode) | |
| 857 : testing::StrictMock<OneClickSigninHelper::SyncStarterWrapper>( | |
| 858 args, start_mode) { | |
| 859 } | |
| 860 | |
| 861 class OneClickSyncStarterWrapperTest : public testing::Test { | |
| 862 public: | |
| 863 void SetUp() override { | |
| 864 TestingProfile::Builder builder; | |
| 865 profile_ = builder.Build(); | |
| 866 } | |
| 867 | |
| 868 void TearDown() override { | |
| 869 // Let the SyncStarterWrapper delete itself. | |
| 870 base::RunLoop().RunUntilIdle(); | |
| 871 } | |
| 872 | |
| 873 void SetCookie(const std::string& value) { | |
| 874 // Set a valid LSID cookie in the test cookie store. | |
| 875 scoped_refptr<net::CookieMonster> cookie_monster = | |
| 876 profile()->GetCookieMonster(); | |
| 877 net::CookieOptions options; | |
| 878 options.set_include_httponly(); | |
| 879 cookie_monster->SetCookieWithOptionsAsync( | |
| 880 GURL("https://accounts.google.com"), | |
| 881 value, options, | |
| 882 net::CookieMonster::SetCookiesCallback()); | |
| 883 } | |
| 884 | |
| 885 void SimulateRefreshTokenFetched( | |
| 886 SigninOAuthHelper::Consumer* consumer, | |
| 887 const std::string& email, | |
| 888 const std::string& display_email, | |
| 889 const std::string& refresh_token) { | |
| 890 consumer->OnSigninOAuthInformationAvailable( | |
| 891 email, display_email, refresh_token); | |
| 892 } | |
| 893 | |
| 894 TestingProfile* profile() { return profile_.get(); } | |
| 895 | |
| 896 private: | |
| 897 content::TestBrowserThreadBundle thread_bundle_; | |
| 898 scoped_ptr<TestingProfile> profile_; | |
| 899 }; | |
| 900 | |
| 901 TEST_F(OneClickSyncStarterWrapperTest, SignInWithRefreshToken) { | |
| 902 OneClickSigninHelper::StartSyncArgs args; | |
| 903 args.email = "foo@gmail.com"; | |
| 904 args.password = "password"; | |
| 905 args.refresh_token = "refresh_token"; | |
| 906 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 907 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 908 | |
| 909 EXPECT_CALL(*wrapper, | |
| 910 StartOneClickSigninSyncStarter("foo@gmail.com", | |
| 911 "refresh_token")); | |
| 912 wrapper->Start(); | |
| 913 } | |
| 914 | |
| 915 TEST_F(OneClickSyncStarterWrapperTest, SignInWithPasswordNoRefreshToken) { | |
| 916 OneClickSigninHelper::StartSyncArgs args; | |
| 917 args.email = "foo@gmail.com"; | |
| 918 args.password = "password"; | |
| 919 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 920 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 921 | |
| 922 EXPECT_CALL(*wrapper, StartSigninOAuthHelper()); | |
| 923 EXPECT_CALL(*wrapper, | |
| 924 StartOneClickSigninSyncStarter("foo@gmail.com", | |
| 925 "refresh_token")); | |
| 926 wrapper->Start(); | |
| 927 SimulateRefreshTokenFetched(wrapper, "foo@gmail.com", "foo@gmail.com", | |
| 928 "refresh_token"); | |
| 929 } | |
| 930 | |
| 931 TEST_F(OneClickSyncStarterWrapperTest, SignInWithWrongEmail) { | |
| 932 OneClickSigninHelper::StartSyncArgs args; | |
| 933 args.email = "foo@gmail.com"; | |
| 934 args.password = "password"; | |
| 935 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 936 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 937 | |
| 938 EXPECT_CALL(*wrapper, StartSigninOAuthHelper()); | |
| 939 EXPECT_CALL(*wrapper, DisplayErrorBubble(_)); | |
| 940 wrapper->Start(); | |
| 941 SimulateRefreshTokenFetched(wrapper, "bar@gmail.com", "bar@gmail.com", | |
| 942 "refresh_token"); | |
| 943 } | |
| 944 | |
| 945 TEST_F(OneClickSyncStarterWrapperTest, SignInWithEmptyPasswordValidCookie) { | |
| 946 OneClickSigninHelper::StartSyncArgs args; | |
| 947 args.email = "foo@gmail.com"; | |
| 948 args.profile = profile(); | |
| 949 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 950 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 951 SetCookie("LSID=1234; secure; httponly"); | |
| 952 | |
| 953 EXPECT_CALL(*wrapper, StartSigninOAuthHelper()); | |
| 954 EXPECT_CALL(*wrapper, | |
| 955 StartOneClickSigninSyncStarter("foo@gmail.com", | |
| 956 "refresh_token")); | |
| 957 wrapper->Start(); | |
| 958 base::RunLoop().RunUntilIdle(); | |
| 959 SimulateRefreshTokenFetched(wrapper, "foo@gmail.com", "foo@gmail.com", | |
| 960 "refresh_token"); | |
| 961 } | |
| 962 | |
| 963 TEST_F(OneClickSyncStarterWrapperTest, SignInWithEmptyPasswordNoCookie) { | |
| 964 OneClickSigninHelper::StartSyncArgs args; | |
| 965 args.email = "foo@gmail.com"; | |
| 966 args.profile = profile(); | |
| 967 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 968 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 969 | |
| 970 EXPECT_CALL(*wrapper, DisplayErrorBubble(_)); | |
| 971 wrapper->Start(); | |
| 972 base::RunLoop().RunUntilIdle(); | |
| 973 } | |
| 974 | |
| 975 TEST_F(OneClickSyncStarterWrapperTest, SignInWithEmptyPasswordInvalidCookie) { | |
| 976 OneClickSigninHelper::StartSyncArgs args; | |
| 977 args.email = "foo@gmail.com"; | |
| 978 args.profile = profile(); | |
| 979 MockStarterWrapper* wrapper = new MockStarterWrapper( | |
| 980 args, OneClickSigninSyncStarter::SYNC_WITH_DEFAULT_SETTINGS); | |
| 981 SetCookie("LSID=1234; domain=google.com; secure; httponly"); | |
| 982 | |
| 983 EXPECT_CALL(*wrapper, DisplayErrorBubble(_)); | |
| 984 wrapper->Start(); | |
| 985 base::RunLoop().RunUntilIdle(); | |
| 986 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 914363003:
Remove OneClickSigninHelper since it is no longer used. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@ocl