| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 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/message_loop/message_loop.h" | |
| 6 #include "base/prefs/pref_service.h" | |
| 7 #include "base/strings/stringprintf.h" | |
| 8 #include "base/synchronization/waitable_event.h" | |
| 9 #include "chrome/browser/browser_process.h" | |
| 10 #include "chrome/browser/chrome_notification_types.h" | |
| 11 #include "chrome/browser/chromeos/login/oauth2_login_manager.h" | |
| 12 #include "chrome/browser/chromeos/login/oauth2_login_manager_factory.h" | |
| 13 #include "chrome/browser/chromeos/login/oobe_base_test.h" | |
| 14 #include "chrome/browser/chromeos/login/user_manager.h" | |
| 15 #include "chrome/browser/chromeos/login/wizard_controller.h" | |
| 16 #include "chrome/browser/extensions/extension_test_message_listener.h" | |
| 17 #include "chrome/browser/profiles/profile_manager.h" | |
| 18 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h" | |
| 19 #include "chrome/browser/ui/app_modal_dialogs/javascript_app_modal_dialog.h" | |
| 20 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h" | |
| 21 #include "chrome/browser/ui/browser.h" | |
| 22 #include "chrome/browser/ui/browser_tabstrip.h" | |
| 23 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h" | |
| 24 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 25 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h" | |
| 26 #include "chrome/test/base/ui_test_utils.h" | |
| 27 #include "components/signin/core/browser/profile_oauth2_token_service.h" | |
| 28 #include "content/public/browser/notification_service.h" | |
| 29 #include "content/public/test/browser_test_utils.h" | |
| 30 #include "extensions/browser/process_manager.h" | |
| 31 #include "google_apis/gaia/gaia_constants.h" | |
| 32 #include "google_apis/gaia/gaia_urls.h" | |
| 33 #include "net/cookies/canonical_cookie.h" | |
| 34 #include "net/cookies/cookie_monster.h" | |
| 35 #include "net/cookies/cookie_store.h" | |
| 36 #include "net/test/embedded_test_server/http_request.h" | |
| 37 #include "net/test/embedded_test_server/http_response.h" | |
| 38 #include "net/url_request/url_request_context.h" | |
| 39 #include "net/url_request/url_request_context_getter.h" | |
| 40 | |
| 41 using net::test_server::BasicHttpResponse; | |
| 42 using net::test_server::HttpRequest; | |
| 43 using net::test_server::HttpResponse; | |
| 44 | |
| 45 namespace chromeos { | |
| 46 | |
| 47 namespace { | |
| 48 | |
| 49 // Email of owner account for test. | |
| 50 const char kTestAccountId[] = "username@gmail.com"; | |
| 51 const char kTestRawAccountId[] = "User.Name"; | |
| 52 const char kTestAccountPassword[] = "fake-password"; | |
| 53 const char kTestAuthCode[] = "fake-auth-code"; | |
| 54 const char kTestGaiaUberToken[] = "fake-uber-token"; | |
| 55 const char kTestAuthLoginAccessToken[] = "fake-access-token"; | |
| 56 const char kTestRefreshToken[] = "fake-refresh-token"; | |
| 57 const char kTestAuthSIDCookie[] = "fake-auth-SID-cookie"; | |
| 58 const char kTestAuthLSIDCookie[] = "fake-auth-LSID-cookie"; | |
| 59 const char kTestSessionSIDCookie[] = "fake-session-SID-cookie"; | |
| 60 const char kTestSessionLSIDCookie[] = "fake-session-LSID-cookie"; | |
| 61 const char kTestSession2SIDCookie[] = "fake-session2-SID-cookie"; | |
| 62 const char kTestSession2LSIDCookie[] = "fake-session2-LSID-cookie"; | |
| 63 const char kTestUserinfoToken[] = "fake-userinfo-token"; | |
| 64 const char kTestLoginToken[] = "fake-login-token"; | |
| 65 const char kTestSyncToken[] = "fake-sync-token"; | |
| 66 const char kTestAuthLoginToken[] = "fake-oauthlogin-token"; | |
| 67 | |
| 68 class OAuth2LoginManagerStateWaiter : public OAuth2LoginManager::Observer { | |
| 69 public: | |
| 70 explicit OAuth2LoginManagerStateWaiter(Profile* profile) | |
| 71 : profile_(profile), | |
| 72 waiting_for_state_(false), | |
| 73 final_state_(OAuth2LoginManager::SESSION_RESTORE_NOT_STARTED) { | |
| 74 } | |
| 75 | |
| 76 void WaitForStates( | |
| 77 const std::set<OAuth2LoginManager::SessionRestoreState>& states) { | |
| 78 DCHECK(!waiting_for_state_); | |
| 79 OAuth2LoginManager* login_manager = | |
| 80 OAuth2LoginManagerFactory::GetInstance()->GetForProfile(profile_); | |
| 81 states_ = states; | |
| 82 if (states_.find(login_manager->state()) != states_.end()) { | |
| 83 final_state_ = login_manager->state(); | |
| 84 return; | |
| 85 } | |
| 86 | |
| 87 waiting_for_state_ = true; | |
| 88 login_manager->AddObserver(this); | |
| 89 runner_ = new content::MessageLoopRunner; | |
| 90 runner_->Run(); | |
| 91 login_manager->RemoveObserver(this); | |
| 92 } | |
| 93 | |
| 94 OAuth2LoginManager::SessionRestoreState final_state() { return final_state_; } | |
| 95 | |
| 96 private: | |
| 97 // OAuth2LoginManager::Observer overrides. | |
| 98 virtual void OnSessionRestoreStateChanged( | |
| 99 Profile* user_profile, | |
| 100 OAuth2LoginManager::SessionRestoreState state) OVERRIDE { | |
| 101 if (!waiting_for_state_) | |
| 102 return; | |
| 103 | |
| 104 if (states_.find(state) == states_.end()) | |
| 105 return; | |
| 106 | |
| 107 final_state_ = state; | |
| 108 waiting_for_state_ = false; | |
| 109 runner_->Quit(); | |
| 110 } | |
| 111 | |
| 112 Profile* profile_; | |
| 113 std::set<OAuth2LoginManager::SessionRestoreState> states_; | |
| 114 bool waiting_for_state_; | |
| 115 OAuth2LoginManager::SessionRestoreState final_state_; | |
| 116 scoped_refptr<content::MessageLoopRunner> runner_; | |
| 117 | |
| 118 DISALLOW_COPY_AND_ASSIGN(OAuth2LoginManagerStateWaiter); | |
| 119 }; | |
| 120 | |
| 121 } // namespace | |
| 122 | |
| 123 class OAuth2Test : public OobeBaseTest { | |
| 124 protected: | |
| 125 OAuth2Test() {} | |
| 126 | |
| 127 void SetupGaiaServerForNewAccount() { | |
| 128 FakeGaia::MergeSessionParams params; | |
| 129 params.auth_sid_cookie = kTestAuthSIDCookie; | |
| 130 params.auth_lsid_cookie = kTestAuthLSIDCookie; | |
| 131 params.auth_code = kTestAuthCode; | |
| 132 params.refresh_token = kTestRefreshToken; | |
| 133 params.access_token = kTestAuthLoginAccessToken; | |
| 134 params.gaia_uber_token = kTestGaiaUberToken; | |
| 135 params.session_sid_cookie = kTestSessionSIDCookie; | |
| 136 params.session_lsid_cookie = kTestSessionLSIDCookie; | |
| 137 fake_gaia_->SetMergeSessionParams(params); | |
| 138 SetupGaiaServerWithAccessTokens(); | |
| 139 } | |
| 140 | |
| 141 void SetupGaiaServerForUnexpiredAccount() { | |
| 142 FakeGaia::MergeSessionParams params; | |
| 143 params.email = kTestAccountId; | |
| 144 fake_gaia_->SetMergeSessionParams(params); | |
| 145 SetupGaiaServerWithAccessTokens(); | |
| 146 } | |
| 147 | |
| 148 void SetupGaiaServerForExpiredAccount() { | |
| 149 FakeGaia::MergeSessionParams params; | |
| 150 params.gaia_uber_token = kTestGaiaUberToken; | |
| 151 params.session_sid_cookie = kTestSession2SIDCookie; | |
| 152 params.session_lsid_cookie = kTestSession2LSIDCookie; | |
| 153 fake_gaia_->SetMergeSessionParams(params); | |
| 154 SetupGaiaServerWithAccessTokens(); | |
| 155 } | |
| 156 | |
| 157 void LoginAsExistingUser() { | |
| 158 content::WindowedNotificationObserver( | |
| 159 chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, | |
| 160 content::NotificationService::AllSources()).Wait(); | |
| 161 | |
| 162 JsExpect("!!document.querySelector('#account-picker')"); | |
| 163 JsExpect("!!document.querySelector('#pod-row')"); | |
| 164 | |
| 165 EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId), | |
| 166 User::OAUTH2_TOKEN_STATUS_VALID); | |
| 167 | |
| 168 EXPECT_TRUE(TryToLogin(kTestAccountId, kTestAccountPassword)); | |
| 169 Profile* profile = ProfileManager::GetPrimaryUserProfile(); | |
| 170 | |
| 171 // Wait for the session merge to finish. | |
| 172 WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE); | |
| 173 | |
| 174 // Check for existance of refresh token. | |
| 175 ProfileOAuth2TokenService* token_service = | |
| 176 ProfileOAuth2TokenServiceFactory::GetForProfile(profile); | |
| 177 EXPECT_TRUE(token_service->RefreshTokenIsAvailable(kTestAccountId)); | |
| 178 | |
| 179 EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId), | |
| 180 User::OAUTH2_TOKEN_STATUS_VALID); | |
| 181 } | |
| 182 | |
| 183 bool TryToLogin(const std::string& username, | |
| 184 const std::string& password) { | |
| 185 if (!AddUserToSession(username, password)) | |
| 186 return false; | |
| 187 | |
| 188 if (const User* active_user = UserManager::Get()->GetActiveUser()) | |
| 189 return active_user->email() == username; | |
| 190 | |
| 191 return false; | |
| 192 } | |
| 193 | |
| 194 User::OAuthTokenStatus GetOAuthStatusFromLocalState( | |
| 195 const std::string& user_id) const { | |
| 196 PrefService* local_state = g_browser_process->local_state(); | |
| 197 const base::DictionaryValue* prefs_oauth_status = | |
| 198 local_state->GetDictionary("OAuthTokenStatus"); | |
| 199 int oauth_token_status = User::OAUTH_TOKEN_STATUS_UNKNOWN; | |
| 200 if (prefs_oauth_status && | |
| 201 prefs_oauth_status->GetIntegerWithoutPathExpansion( | |
| 202 user_id, &oauth_token_status)) { | |
| 203 User::OAuthTokenStatus result = | |
| 204 static_cast<User::OAuthTokenStatus>(oauth_token_status); | |
| 205 return result; | |
| 206 } | |
| 207 return User::OAUTH_TOKEN_STATUS_UNKNOWN; | |
| 208 } | |
| 209 | |
| 210 protected: | |
| 211 // OobeBaseTest overrides. | |
| 212 virtual Profile* profile() OVERRIDE { | |
| 213 if (UserManager::Get()->GetActiveUser()) | |
| 214 return ProfileManager::GetPrimaryUserProfile(); | |
| 215 | |
| 216 return OobeBaseTest::profile(); | |
| 217 } | |
| 218 | |
| 219 bool AddUserToSession(const std::string& username, | |
| 220 const std::string& password) { | |
| 221 ExistingUserController* controller = | |
| 222 ExistingUserController::current_controller(); | |
| 223 if (!controller) { | |
| 224 ADD_FAILURE(); | |
| 225 return false; | |
| 226 } | |
| 227 | |
| 228 controller->Login(UserContext(username, password, std::string())); | |
| 229 content::WindowedNotificationObserver( | |
| 230 chrome::NOTIFICATION_SESSION_STARTED, | |
| 231 content::NotificationService::AllSources()).Wait(); | |
| 232 const UserList& logged_users = UserManager::Get()->GetLoggedInUsers(); | |
| 233 for (UserList::const_iterator it = logged_users.begin(); | |
| 234 it != logged_users.end(); ++it) { | |
| 235 if ((*it)->email() == username) | |
| 236 return true; | |
| 237 } | |
| 238 return false; | |
| 239 } | |
| 240 | |
| 241 void SetupGaiaServerWithAccessTokens() { | |
| 242 // Configure OAuth authentication. | |
| 243 GaiaUrls* gaia_urls = GaiaUrls::GetInstance(); | |
| 244 | |
| 245 // This token satisfies the userinfo.email request from | |
| 246 // DeviceOAuth2TokenService used in token validation. | |
| 247 FakeGaia::AccessTokenInfo userinfo_token_info; | |
| 248 userinfo_token_info.token = kTestUserinfoToken; | |
| 249 userinfo_token_info.scopes.insert( | |
| 250 "https://www.googleapis.com/auth/userinfo.email"); | |
| 251 userinfo_token_info.audience = gaia_urls->oauth2_chrome_client_id(); | |
| 252 userinfo_token_info.email = kTestAccountId; | |
| 253 fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_token_info); | |
| 254 | |
| 255 FakeGaia::AccessTokenInfo userinfo_profile_token_info; | |
| 256 userinfo_profile_token_info.token = kTestUserinfoToken; | |
| 257 userinfo_profile_token_info.scopes.insert( | |
| 258 "https://www.googleapis.com/auth/userinfo.profile"); | |
| 259 userinfo_profile_token_info.audience = gaia_urls->oauth2_chrome_client_id(); | |
| 260 userinfo_profile_token_info.email = kTestAccountId; | |
| 261 fake_gaia_->IssueOAuthToken(kTestRefreshToken, userinfo_profile_token_info); | |
| 262 | |
| 263 // The any-api access token for accessing the token minting endpoint. | |
| 264 FakeGaia::AccessTokenInfo login_token_info; | |
| 265 login_token_info.token = kTestLoginToken; | |
| 266 login_token_info.scopes.insert(GaiaConstants::kAnyApiOAuth2Scope); | |
| 267 login_token_info.audience = gaia_urls->oauth2_chrome_client_id(); | |
| 268 fake_gaia_->IssueOAuthToken(kTestRefreshToken, login_token_info); | |
| 269 | |
| 270 // The /auth/chromesync access token for accessing sync endpoint. | |
| 271 FakeGaia::AccessTokenInfo sync_token_info; | |
| 272 sync_token_info.token = kTestSyncToken; | |
| 273 sync_token_info.scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope); | |
| 274 sync_token_info.audience = gaia_urls->oauth2_chrome_client_id(); | |
| 275 fake_gaia_->IssueOAuthToken(kTestRefreshToken, sync_token_info); | |
| 276 | |
| 277 FakeGaia::AccessTokenInfo auth_login_token_info; | |
| 278 auth_login_token_info.token = kTestAuthLoginToken; | |
| 279 auth_login_token_info.scopes.insert(GaiaConstants::kOAuth1LoginScope); | |
| 280 auth_login_token_info.audience = gaia_urls->oauth2_chrome_client_id(); | |
| 281 fake_gaia_->IssueOAuthToken(kTestRefreshToken, auth_login_token_info); | |
| 282 } | |
| 283 | |
| 284 void CheckSessionState(OAuth2LoginManager::SessionRestoreState state) { | |
| 285 OAuth2LoginManager* login_manager = | |
| 286 OAuth2LoginManagerFactory::GetInstance()->GetForProfile( | |
| 287 profile()); | |
| 288 ASSERT_EQ(state, login_manager->state()); | |
| 289 } | |
| 290 | |
| 291 void WaitForMergeSessionCompletion( | |
| 292 OAuth2LoginManager::SessionRestoreState final_state) { | |
| 293 // Wait for the session merge to finish. | |
| 294 std::set<OAuth2LoginManager::SessionRestoreState> states; | |
| 295 states.insert(OAuth2LoginManager::SESSION_RESTORE_DONE); | |
| 296 states.insert(OAuth2LoginManager::SESSION_RESTORE_FAILED); | |
| 297 states.insert(OAuth2LoginManager::SESSION_RESTORE_CONNECTION_FAILED); | |
| 298 OAuth2LoginManagerStateWaiter merge_session_waiter(profile()); | |
| 299 merge_session_waiter.WaitForStates(states); | |
| 300 EXPECT_EQ(merge_session_waiter.final_state(), final_state); | |
| 301 } | |
| 302 | |
| 303 void StartNewUserSession(bool wait_for_merge) { | |
| 304 SetupGaiaServerForNewAccount(); | |
| 305 SimulateNetworkOnline(); | |
| 306 chromeos::WizardController::SkipPostLoginScreensForTesting(); | |
| 307 chromeos::WizardController* wizard_controller = | |
| 308 chromeos::WizardController::default_controller(); | |
| 309 wizard_controller->SkipToLoginForTesting(LoginScreenContext()); | |
| 310 | |
| 311 content::WindowedNotificationObserver( | |
| 312 chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, | |
| 313 content::NotificationService::AllSources()).Wait(); | |
| 314 | |
| 315 // Use capitalized and dotted user name on purpose to make sure | |
| 316 // our email normalization kicks in. | |
| 317 GetLoginDisplay()->ShowSigninScreenForCreds(kTestRawAccountId, | |
| 318 kTestAccountPassword); | |
| 319 | |
| 320 content::WindowedNotificationObserver( | |
| 321 chrome::NOTIFICATION_SESSION_STARTED, | |
| 322 content::NotificationService::AllSources()).Wait(); | |
| 323 | |
| 324 if (wait_for_merge) { | |
| 325 // Wait for the session merge to finish. | |
| 326 WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE); | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 DISALLOW_COPY_AND_ASSIGN(OAuth2Test); | |
| 331 }; | |
| 332 | |
| 333 class CookieReader : public base::RefCountedThreadSafe<CookieReader> { | |
| 334 public: | |
| 335 CookieReader() { | |
| 336 } | |
| 337 | |
| 338 void ReadCookies(Profile* profile) { | |
| 339 context_ = profile->GetRequestContext(); | |
| 340 content::BrowserThread::PostTask( | |
| 341 content::BrowserThread::IO, FROM_HERE, | |
| 342 base::Bind(&CookieReader::ReadCookiesOnIOThread, | |
| 343 this)); | |
| 344 runner_ = new content::MessageLoopRunner; | |
| 345 runner_->Run(); | |
| 346 } | |
| 347 | |
| 348 std::string GetCookieValue(const std::string& name) { | |
| 349 for (std::vector<net::CanonicalCookie>::const_iterator iter = | |
| 350 cookie_list_.begin(); | |
| 351 iter != cookie_list_.end(); | |
| 352 ++iter) { | |
| 353 if (iter->Name() == name) { | |
| 354 return iter->Value(); | |
| 355 } | |
| 356 } | |
| 357 return std::string(); | |
| 358 } | |
| 359 | |
| 360 private: | |
| 361 friend class base::RefCountedThreadSafe<CookieReader>; | |
| 362 | |
| 363 virtual ~CookieReader() { | |
| 364 } | |
| 365 | |
| 366 void ReadCookiesOnIOThread() { | |
| 367 context_->GetURLRequestContext()->cookie_store()->GetCookieMonster()-> | |
| 368 GetAllCookiesAsync(base::Bind( | |
| 369 &CookieReader::OnGetAllCookiesOnUIThread, | |
| 370 this)); | |
| 371 } | |
| 372 | |
| 373 void OnGetAllCookiesOnUIThread(const net::CookieList& cookies) { | |
| 374 cookie_list_ = cookies; | |
| 375 content::BrowserThread::PostTask( | |
| 376 content::BrowserThread::UI, FROM_HERE, | |
| 377 base::Bind(&CookieReader::OnCookiesReadyOnUIThread, | |
| 378 this)); | |
| 379 } | |
| 380 | |
| 381 void OnCookiesReadyOnUIThread() { | |
| 382 runner_->Quit(); | |
| 383 } | |
| 384 | |
| 385 scoped_refptr<net::URLRequestContextGetter> context_; | |
| 386 net::CookieList cookie_list_; | |
| 387 scoped_refptr<content::MessageLoopRunner> runner_; | |
| 388 | |
| 389 DISALLOW_COPY_AND_ASSIGN(CookieReader); | |
| 390 }; | |
| 391 | |
| 392 // PRE_MergeSession is testing merge session for a new profile. | |
| 393 IN_PROC_BROWSER_TEST_F(OAuth2Test, PRE_PRE_PRE_MergeSession) { | |
| 394 StartNewUserSession(true); | |
| 395 // Check for existance of refresh token. | |
| 396 ProfileOAuth2TokenService* token_service = | |
| 397 ProfileOAuth2TokenServiceFactory::GetForProfile( | |
| 398 profile()); | |
| 399 EXPECT_TRUE(token_service->RefreshTokenIsAvailable(kTestAccountId)); | |
| 400 | |
| 401 EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId), | |
| 402 User::OAUTH2_TOKEN_STATUS_VALID); | |
| 403 | |
| 404 scoped_refptr<CookieReader> cookie_reader(new CookieReader()); | |
| 405 cookie_reader->ReadCookies(profile()); | |
| 406 EXPECT_EQ(cookie_reader->GetCookieValue("SID"), kTestSessionSIDCookie); | |
| 407 EXPECT_EQ(cookie_reader->GetCookieValue("LSID"), kTestSessionLSIDCookie); | |
| 408 } | |
| 409 | |
| 410 // MergeSession test is running merge session process for an existing profile | |
| 411 // that was generated in PRE_PRE_PRE_MergeSession test. In this test, we | |
| 412 // are not running /MergeSession process since the /ListAccounts call confirms | |
| 413 // that the session is not stale. | |
| 414 IN_PROC_BROWSER_TEST_F(OAuth2Test, PRE_PRE_MergeSession) { | |
| 415 SetupGaiaServerForUnexpiredAccount(); | |
| 416 SimulateNetworkOnline(); | |
| 417 LoginAsExistingUser(); | |
| 418 scoped_refptr<CookieReader> cookie_reader(new CookieReader()); | |
| 419 cookie_reader->ReadCookies(profile()); | |
| 420 // These are still cookie values form the initial session since | |
| 421 // /ListAccounts | |
| 422 EXPECT_EQ(cookie_reader->GetCookieValue("SID"), kTestSessionSIDCookie); | |
| 423 EXPECT_EQ(cookie_reader->GetCookieValue("LSID"), kTestSessionLSIDCookie); | |
| 424 } | |
| 425 | |
| 426 // MergeSession test is running merge session process for an existing profile | |
| 427 // that was generated in PRE_PRE_MergeSession test. | |
| 428 IN_PROC_BROWSER_TEST_F(OAuth2Test, PRE_MergeSession) { | |
| 429 SetupGaiaServerForExpiredAccount(); | |
| 430 SimulateNetworkOnline(); | |
| 431 LoginAsExistingUser(); | |
| 432 scoped_refptr<CookieReader> cookie_reader(new CookieReader()); | |
| 433 cookie_reader->ReadCookies(profile()); | |
| 434 // These should be cookie values that we generated by calling /MergeSession, | |
| 435 // since /ListAccounts should have tell us that the initial session cookies | |
| 436 // are stale. | |
| 437 EXPECT_EQ(cookie_reader->GetCookieValue("SID"), kTestSession2SIDCookie); | |
| 438 EXPECT_EQ(cookie_reader->GetCookieValue("LSID"), kTestSession2LSIDCookie); | |
| 439 } | |
| 440 | |
| 441 // MergeSession test is attempting to merge session for an existing profile | |
| 442 // that was generated in PRE_PRE_MergeSession test. This attempt should fail | |
| 443 // since FakeGaia instance isn't configured to return relevant tokens/cookies. | |
| 444 IN_PROC_BROWSER_TEST_F(OAuth2Test, MergeSession) { | |
| 445 SimulateNetworkOnline(); | |
| 446 | |
| 447 content::WindowedNotificationObserver( | |
| 448 chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE, | |
| 449 content::NotificationService::AllSources()).Wait(); | |
| 450 | |
| 451 JsExpect("!!document.querySelector('#account-picker')"); | |
| 452 JsExpect("!!document.querySelector('#pod-row')"); | |
| 453 | |
| 454 EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId), | |
| 455 User::OAUTH2_TOKEN_STATUS_VALID); | |
| 456 | |
| 457 EXPECT_TRUE(TryToLogin(kTestAccountId, kTestAccountPassword)); | |
| 458 | |
| 459 // Wait for the session merge to finish. | |
| 460 WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_FAILED); | |
| 461 | |
| 462 EXPECT_EQ(GetOAuthStatusFromLocalState(kTestAccountId), | |
| 463 User::OAUTH2_TOKEN_STATUS_INVALID); | |
| 464 } | |
| 465 | |
| 466 | |
| 467 const char kGooglePageContent[] = | |
| 468 "<html><title>Hello!</title><script>alert('hello');</script>" | |
| 469 "<body>Hello Google!</body></html>"; | |
| 470 const char kRandomPageContent[] = | |
| 471 "<html><title>SomthingElse</title><body>I am SomethingElse</body></html>"; | |
| 472 const char kHelloPagePath[] = "/hello_google"; | |
| 473 const char kRandomPagePath[] = "/non_google_page"; | |
| 474 | |
| 475 | |
| 476 // FakeGoogle serves content of http://www.google.com/hello_google page for | |
| 477 // merge session tests. | |
| 478 class FakeGoogle { | |
| 479 public: | |
| 480 FakeGoogle() : start_event_(true, false) { | |
| 481 } | |
| 482 | |
| 483 ~FakeGoogle() {} | |
| 484 | |
| 485 scoped_ptr<HttpResponse> HandleRequest(const HttpRequest& request) { | |
| 486 // The scheme and host of the URL is actually not important but required to | |
| 487 // get a valid GURL in order to parse |request.relative_url|. | |
| 488 GURL request_url = GURL("http://localhost").Resolve(request.relative_url); | |
| 489 LOG(WARNING) << "Requesting page " << request.relative_url; | |
| 490 std::string request_path = request_url.path(); | |
| 491 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse()); | |
| 492 if (request_path == kHelloPagePath) { // Serving "google" page. | |
| 493 start_event_.Signal(); | |
| 494 content::BrowserThread::PostTask( | |
| 495 content::BrowserThread::UI, FROM_HERE, | |
| 496 base::Bind(&FakeGoogle::QuitRunnerOnUIThread, | |
| 497 base::Unretained(this))); | |
| 498 | |
| 499 http_response->set_code(net::HTTP_OK); | |
| 500 http_response->set_content_type("text/html"); | |
| 501 http_response->set_content(kGooglePageContent); | |
| 502 } else if (request_path == kRandomPagePath) { // Serving "non-google" page. | |
| 503 http_response->set_code(net::HTTP_OK); | |
| 504 http_response->set_content_type("text/html"); | |
| 505 http_response->set_content(kRandomPageContent); | |
| 506 } else { | |
| 507 return scoped_ptr<HttpResponse>(); // Request not understood. | |
| 508 } | |
| 509 | |
| 510 return http_response.PassAs<HttpResponse>(); | |
| 511 } | |
| 512 | |
| 513 // True if we have already served the test page. | |
| 514 bool IsPageRequested () { | |
| 515 return start_event_.IsSignaled(); | |
| 516 } | |
| 517 | |
| 518 // Waits until we receive a request to serve the test page. | |
| 519 void WaitForPageRequest() { | |
| 520 // If we have already served the request, bail out. | |
| 521 if (start_event_.IsSignaled()) | |
| 522 return; | |
| 523 | |
| 524 runner_ = new content::MessageLoopRunner; | |
| 525 runner_->Run(); | |
| 526 } | |
| 527 | |
| 528 private: | |
| 529 void QuitRunnerOnUIThread() { | |
| 530 if (runner_.get()) | |
| 531 runner_->Quit(); | |
| 532 } | |
| 533 // This event will tell us when we actually see HTTP request on the server | |
| 534 // side. It should be signalled only after the page/XHR throttle had been | |
| 535 // removed (after merge session completes). | |
| 536 base::WaitableEvent start_event_; | |
| 537 scoped_refptr<content::MessageLoopRunner> runner_; | |
| 538 | |
| 539 DISALLOW_COPY_AND_ASSIGN(FakeGoogle); | |
| 540 }; | |
| 541 | |
| 542 // FakeGaia specialization that can delay /MergeSession handler until | |
| 543 // we explicitly call DelayedFakeGaia::UnblockMergeSession(). | |
| 544 class DelayedFakeGaia : public FakeGaia { | |
| 545 public: | |
| 546 DelayedFakeGaia() | |
| 547 : blocking_event_(true, false), | |
| 548 start_event_(true, false) { | |
| 549 } | |
| 550 | |
| 551 void UnblockMergeSession() { | |
| 552 blocking_event_.Signal(); | |
| 553 } | |
| 554 | |
| 555 void WaitForMergeSessionToStart() { | |
| 556 // If we have already served the request, bail out. | |
| 557 if (start_event_.IsSignaled()) | |
| 558 return; | |
| 559 | |
| 560 runner_ = new content::MessageLoopRunner; | |
| 561 runner_->Run(); | |
| 562 } | |
| 563 | |
| 564 private: | |
| 565 // FakeGaia overrides. | |
| 566 virtual void HandleMergeSession(const HttpRequest& request, | |
| 567 BasicHttpResponse* http_response) OVERRIDE { | |
| 568 start_event_.Signal(); | |
| 569 content::BrowserThread::PostTask( | |
| 570 content::BrowserThread::UI, FROM_HERE, | |
| 571 base::Bind(&DelayedFakeGaia::QuitRunnerOnUIThread, | |
| 572 base::Unretained(this))); | |
| 573 blocking_event_.Wait(); | |
| 574 FakeGaia::HandleMergeSession(request, http_response); | |
| 575 } | |
| 576 | |
| 577 void QuitRunnerOnUIThread() { | |
| 578 if (runner_.get()) | |
| 579 runner_->Quit(); | |
| 580 } | |
| 581 | |
| 582 base::WaitableEvent blocking_event_; | |
| 583 base::WaitableEvent start_event_; | |
| 584 scoped_refptr<content::MessageLoopRunner> runner_; | |
| 585 | |
| 586 DISALLOW_COPY_AND_ASSIGN(DelayedFakeGaia); | |
| 587 }; | |
| 588 | |
| 589 class MergeSessionTest : public OAuth2Test { | |
| 590 protected: | |
| 591 MergeSessionTest() : delayed_fake_gaia_(new DelayedFakeGaia()) { | |
| 592 fake_gaia_.reset(delayed_fake_gaia_); | |
| 593 } | |
| 594 | |
| 595 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { | |
| 596 OAuth2Test::SetUpCommandLine(command_line); | |
| 597 | |
| 598 // Get fake URL for fake google.com. | |
| 599 const GURL& server_url = embedded_test_server()->base_url(); | |
| 600 std::string google_host("www.google.com"); | |
| 601 GURL::Replacements replace_google_host; | |
| 602 replace_google_host.SetHostStr(google_host); | |
| 603 GURL google_url = server_url.ReplaceComponents(replace_google_host); | |
| 604 fake_google_page_url_ = google_url.Resolve(kHelloPagePath); | |
| 605 | |
| 606 std::string non_google_host("www.somethingelse.org"); | |
| 607 GURL::Replacements replace_non_google_host; | |
| 608 replace_non_google_host.SetHostStr(non_google_host); | |
| 609 GURL non_google_url = server_url.ReplaceComponents(replace_non_google_host); | |
| 610 non_google_page_url_ = non_google_url.Resolve(kRandomPagePath); | |
| 611 } | |
| 612 | |
| 613 virtual void SetUp() OVERRIDE { | |
| 614 embedded_test_server()->RegisterRequestHandler( | |
| 615 base::Bind(&FakeGoogle::HandleRequest, | |
| 616 base::Unretained(&fake_google_))); | |
| 617 OAuth2Test::SetUp(); | |
| 618 } | |
| 619 | |
| 620 protected: | |
| 621 void UnblockMergeSession() { | |
| 622 delayed_fake_gaia_->UnblockMergeSession(); | |
| 623 } | |
| 624 | |
| 625 void WaitForMergeSessionToStart() { | |
| 626 delayed_fake_gaia_->WaitForMergeSessionToStart(); | |
| 627 } | |
| 628 | |
| 629 void JsExpect(content::WebContents* contents, | |
| 630 const std::string& expression) { | |
| 631 bool result; | |
| 632 ASSERT_TRUE(content::ExecuteScriptAndExtractBool( | |
| 633 contents, | |
| 634 "window.domAutomationController.send(!!(" + expression + "));", | |
| 635 &result)); | |
| 636 ASSERT_TRUE(result) << expression; | |
| 637 } | |
| 638 | |
| 639 const GURL& GetBackGroundPageUrl(const std::string& extension_id) { | |
| 640 extensions::ProcessManager* manager = | |
| 641 extensions::ExtensionSystem::Get(profile())->process_manager(); | |
| 642 extensions::ExtensionHost* host = | |
| 643 manager->GetBackgroundHostForExtension(extension_id); | |
| 644 return host->host_contents()->GetURL(); | |
| 645 } | |
| 646 | |
| 647 void JsExpectOnBackgroundPage(const std::string& extension_id, | |
| 648 const std::string& expression) { | |
| 649 extensions::ProcessManager* manager = | |
| 650 extensions::ExtensionSystem::Get(profile())->process_manager(); | |
| 651 extensions::ExtensionHost* host = | |
| 652 manager->GetBackgroundHostForExtension(extension_id); | |
| 653 if (host == NULL) { | |
| 654 ADD_FAILURE() << "Extension " << extension_id | |
| 655 << " has no background page."; | |
| 656 return; | |
| 657 } | |
| 658 | |
| 659 JsExpect(host->host_contents(), expression); | |
| 660 } | |
| 661 | |
| 662 FakeGoogle fake_google_; | |
| 663 DelayedFakeGaia* delayed_fake_gaia_; | |
| 664 GURL fake_google_page_url_; | |
| 665 GURL non_google_page_url_; | |
| 666 | |
| 667 private: | |
| 668 DISALLOW_COPY_AND_ASSIGN(MergeSessionTest); | |
| 669 }; | |
| 670 | |
| 671 Browser* FindOrCreateVisibleBrowser(Profile* profile) { | |
| 672 chrome::ScopedTabbedBrowserDisplayer displayer( | |
| 673 profile, chrome::GetActiveDesktop()); | |
| 674 Browser* browser = displayer.browser(); | |
| 675 if (browser->tab_strip_model()->count() == 0) | |
| 676 chrome::AddTabAt(browser, GURL(), -1, true); | |
| 677 return browser; | |
| 678 } | |
| 679 | |
| 680 IN_PROC_BROWSER_TEST_F(MergeSessionTest, PageThrottle) { | |
| 681 StartNewUserSession(false); | |
| 682 | |
| 683 // Try to open a page from google.com. | |
| 684 Browser* browser = | |
| 685 FindOrCreateVisibleBrowser(profile()); | |
| 686 ui_test_utils::NavigateToURLWithDisposition( | |
| 687 browser, | |
| 688 fake_google_page_url_, | |
| 689 CURRENT_TAB, ui_test_utils::BROWSER_TEST_NONE); | |
| 690 | |
| 691 // Wait until we get send merge session request. | |
| 692 WaitForMergeSessionToStart(); | |
| 693 | |
| 694 // Make sure the page is blocked by the throttle. | |
| 695 EXPECT_FALSE(fake_google_.IsPageRequested()); | |
| 696 | |
| 697 // Check that throttle page is displayed instead. | |
| 698 base::string16 title; | |
| 699 ui_test_utils::GetCurrentTabTitle(browser, &title); | |
| 700 DVLOG(1) << "Loaded page at the start : " << title; | |
| 701 | |
| 702 // Unblock GAIA request. | |
| 703 UnblockMergeSession(); | |
| 704 | |
| 705 // Wait for the session merge to finish. | |
| 706 WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE); | |
| 707 | |
| 708 // Make sure the test page is served. | |
| 709 fake_google_.WaitForPageRequest(); | |
| 710 | |
| 711 // Check that real page is no longer blocked by the throttle and that the | |
| 712 // real page pops up JS dialog. | |
| 713 AppModalDialog* dialog = ui_test_utils::WaitForAppModalDialog(); | |
| 714 ASSERT_TRUE(dialog->IsJavaScriptModalDialog()); | |
| 715 JavaScriptAppModalDialog* js_dialog = | |
| 716 static_cast<JavaScriptAppModalDialog*>(dialog); | |
| 717 js_dialog->native_dialog()->AcceptAppModalDialog(); | |
| 718 | |
| 719 ui_test_utils::GetCurrentTabTitle(browser, &title); | |
| 720 DVLOG(1) << "Loaded page at the end : " << title; | |
| 721 } | |
| 722 | |
| 723 IN_PROC_BROWSER_TEST_F(MergeSessionTest, XHRThrottle) { | |
| 724 StartNewUserSession(false); | |
| 725 | |
| 726 // Wait until we get send merge session request. | |
| 727 WaitForMergeSessionToStart(); | |
| 728 | |
| 729 // Reset ExtensionBrowserTest::observer_ to the right browser object. | |
| 730 Browser* browser = FindOrCreateVisibleBrowser(profile()); | |
| 731 observer_.reset(new ExtensionTestNotificationObserver(browser)); | |
| 732 | |
| 733 // Run background page tests. The tests will just wait for XHR request | |
| 734 // to complete. | |
| 735 ResultCatcher catcher; | |
| 736 | |
| 737 scoped_ptr<ExtensionTestMessageListener> non_google_xhr_listener( | |
| 738 new ExtensionTestMessageListener("non-google-xhr-received", false)); | |
| 739 | |
| 740 // Load extension with a background page. The background page will | |
| 741 // attempt to load |fake_google_page_url_| via XHR. | |
| 742 const extensions::Extension* ext = LoadExtension( | |
| 743 test_data_dir_.AppendASCII("merge_session")); | |
| 744 ASSERT_TRUE(ext); | |
| 745 | |
| 746 // Kick off XHR request from the extension. | |
| 747 JsExpectOnBackgroundPage( | |
| 748 ext->id(), | |
| 749 base::StringPrintf("startThrottledTests('%s', '%s')", | |
| 750 fake_google_page_url_.spec().c_str(), | |
| 751 non_google_page_url_.spec().c_str())); | |
| 752 | |
| 753 // Verify that we've sent XHR request form the extension side... | |
| 754 JsExpectOnBackgroundPage(ext->id(), | |
| 755 "googleRequestSent && !googleResponseReceived"); | |
| 756 | |
| 757 // ...but didn't see it on the server side yet. | |
| 758 EXPECT_FALSE(fake_google_.IsPageRequested()); | |
| 759 | |
| 760 // Unblock GAIA request. | |
| 761 UnblockMergeSession(); | |
| 762 | |
| 763 // Wait for the session merge to finish. | |
| 764 WaitForMergeSessionCompletion(OAuth2LoginManager::SESSION_RESTORE_DONE); | |
| 765 | |
| 766 // Wait until non-google XHR content to load first. | |
| 767 ASSERT_TRUE(non_google_xhr_listener->WaitUntilSatisfied()); | |
| 768 | |
| 769 if (!catcher.GetNextResult()) { | |
| 770 std::string message = catcher.message(); | |
| 771 ADD_FAILURE() << "Tests failed: " << message; | |
| 772 } | |
| 773 | |
| 774 EXPECT_TRUE(fake_google_.IsPageRequested()); | |
| 775 } | |
| 776 | |
| 777 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 286933002:
[cros login] Split login related classes into subfolders. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src