OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/password_manager/password_manager_test_base.h" | 5 #include "chrome/browser/password_manager/password_manager_test_base.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 }; | 59 }; |
60 | 60 |
61 // ManagePasswordsUIController subclass to capture the UI events. | 61 // ManagePasswordsUIController subclass to capture the UI events. |
62 class CustomManagePasswordsUIController : public ManagePasswordsUIController { | 62 class CustomManagePasswordsUIController : public ManagePasswordsUIController { |
63 public: | 63 public: |
64 explicit CustomManagePasswordsUIController( | 64 explicit CustomManagePasswordsUIController( |
65 content::WebContents* web_contents); | 65 content::WebContents* web_contents); |
66 | 66 |
67 void WaitForState(password_manager::ui::State target_state); | 67 void WaitForState(password_manager::ui::State target_state); |
68 | 68 |
| 69 void WaitForFallbackForSaving(); |
| 70 |
| 71 bool was_prompt_automatically_shown() { |
| 72 return was_prompt_automatically_shown_; |
| 73 } |
| 74 |
69 private: | 75 private: |
70 // PasswordsClientUIDelegate: | 76 // PasswordsClientUIDelegate: |
71 void OnPasswordSubmitted( | 77 void OnPasswordSubmitted( |
72 std::unique_ptr<password_manager::PasswordFormManager> form_manager) | 78 std::unique_ptr<password_manager::PasswordFormManager> form_manager) |
73 override; | 79 override; |
| 80 void OnUpdatePasswordSubmitted( |
| 81 std::unique_ptr<password_manager::PasswordFormManager> form_manager) |
| 82 override; |
| 83 void OnShowManualFallbackForSaving( |
| 84 std::unique_ptr<password_manager::PasswordFormManager> form_manager, |
| 85 bool has_generated_password, |
| 86 bool is_update) override; |
74 bool OnChooseCredentials( | 87 bool OnChooseCredentials( |
75 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, | 88 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, |
76 const GURL& origin, | 89 const GURL& origin, |
77 const ManagePasswordsState::CredentialsCallback& callback) override; | 90 const ManagePasswordsState::CredentialsCallback& callback) override; |
78 void OnPasswordAutofilled( | 91 void OnPasswordAutofilled( |
79 const std::map<base::string16, const autofill::PasswordForm*>& | 92 const std::map<base::string16, const autofill::PasswordForm*>& |
80 password_form_map, | 93 password_form_map, |
81 const GURL& origin, | 94 const GURL& origin, |
82 const std::vector<const autofill::PasswordForm*>* federated_matches) | 95 const std::vector<const autofill::PasswordForm*>* federated_matches) |
83 override; | 96 override; |
84 | 97 |
85 // The loop to be stopped when the target state is observed. | 98 // Should not be used for manual fallback events. |
| 99 bool IsTargetStateObserved( |
| 100 const password_manager::ui::State target_state, |
| 101 const password_manager::ui::State current_state) const; |
| 102 |
| 103 void ProcessStateExpectations( |
| 104 const password_manager::ui::State current_state); |
| 105 |
| 106 // Quits |run_loop_| and clears expectations. |
| 107 void QuitRunLoop(); |
| 108 |
| 109 // The loop to be stopped when the target state or fallback is observed. |
86 base::RunLoop* run_loop_; | 110 base::RunLoop* run_loop_; |
87 | 111 |
88 // The state CustomManagePasswordsUIController is currently waiting for. | 112 // The state CustomManagePasswordsUIController is currently waiting for. |
| 113 // Manual fallback events don't interrupt waiting. |
89 password_manager::ui::State target_state_; | 114 password_manager::ui::State target_state_; |
90 | 115 |
| 116 // True iff showing fallback is waited. |
| 117 bool wait_for_fallback_; |
| 118 |
| 119 // True iff a prompt was automatically shown. |
| 120 bool was_prompt_automatically_shown_; |
| 121 |
91 DISALLOW_COPY_AND_ASSIGN(CustomManagePasswordsUIController); | 122 DISALLOW_COPY_AND_ASSIGN(CustomManagePasswordsUIController); |
92 }; | 123 }; |
93 | 124 |
94 CustomManagePasswordsUIController::CustomManagePasswordsUIController( | 125 CustomManagePasswordsUIController::CustomManagePasswordsUIController( |
95 content::WebContents* web_contents) | 126 content::WebContents* web_contents) |
96 : ManagePasswordsUIController(web_contents), | 127 : ManagePasswordsUIController(web_contents), |
97 run_loop_(nullptr), | 128 run_loop_(nullptr), |
98 target_state_(password_manager::ui::INACTIVE_STATE) { | 129 target_state_(password_manager::ui::INACTIVE_STATE), |
| 130 wait_for_fallback_(false), |
| 131 was_prompt_automatically_shown_(false) { |
99 // Attach CustomManagePasswordsUIController to |web_contents| so the default | 132 // Attach CustomManagePasswordsUIController to |web_contents| so the default |
100 // ManagePasswordsUIController isn't created. | 133 // ManagePasswordsUIController isn't created. |
101 // Do not silently replace an existing ManagePasswordsUIController because it | 134 // Do not silently replace an existing ManagePasswordsUIController because it |
102 // unregisters itself in WebContentsDestroyed(). | 135 // unregisters itself in WebContentsDestroyed(). |
103 EXPECT_FALSE(web_contents->GetUserData(UserDataKey())); | 136 EXPECT_FALSE(web_contents->GetUserData(UserDataKey())); |
104 web_contents->SetUserData(UserDataKey(), base::WrapUnique(this)); | 137 web_contents->SetUserData(UserDataKey(), base::WrapUnique(this)); |
105 } | 138 } |
106 | 139 |
107 void CustomManagePasswordsUIController::WaitForState( | 140 void CustomManagePasswordsUIController::WaitForState( |
108 password_manager::ui::State target_state) { | 141 password_manager::ui::State target_state) { |
| 142 if (IsTargetStateObserved(target_state, GetState())) |
| 143 return; |
| 144 |
109 base::RunLoop run_loop; | 145 base::RunLoop run_loop; |
110 target_state_ = target_state; | 146 target_state_ = target_state; |
111 run_loop_ = &run_loop; | 147 run_loop_ = &run_loop; |
112 run_loop_->Run(); | 148 run_loop_->Run(); |
113 } | 149 } |
114 | 150 |
| 151 void CustomManagePasswordsUIController::WaitForFallbackForSaving() { |
| 152 if (!was_prompt_automatically_shown_ && |
| 153 GetState() == password_manager::ui::PENDING_PASSWORD_STATE) |
| 154 return; |
| 155 |
| 156 base::RunLoop run_loop; |
| 157 wait_for_fallback_ = true; |
| 158 run_loop_ = &run_loop; |
| 159 run_loop_->Run(); |
| 160 } |
| 161 |
115 void CustomManagePasswordsUIController::OnPasswordSubmitted( | 162 void CustomManagePasswordsUIController::OnPasswordSubmitted( |
116 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { | 163 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { |
117 if (target_state_ == password_manager::ui::PENDING_PASSWORD_STATE) { | 164 was_prompt_automatically_shown_ = true; |
118 run_loop_->Quit(); | 165 ProcessStateExpectations(password_manager::ui::PENDING_PASSWORD_STATE); |
119 run_loop_ = nullptr; | |
120 target_state_ = password_manager::ui::INACTIVE_STATE; | |
121 } | |
122 return ManagePasswordsUIController::OnPasswordSubmitted( | 166 return ManagePasswordsUIController::OnPasswordSubmitted( |
123 std::move(form_manager)); | 167 std::move(form_manager)); |
124 } | 168 } |
125 | 169 |
| 170 void CustomManagePasswordsUIController::OnUpdatePasswordSubmitted( |
| 171 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { |
| 172 was_prompt_automatically_shown_ = true; |
| 173 ProcessStateExpectations(password_manager::ui::PENDING_PASSWORD_UPDATE_STATE); |
| 174 return ManagePasswordsUIController::OnUpdatePasswordSubmitted( |
| 175 std::move(form_manager)); |
| 176 } |
| 177 |
| 178 void CustomManagePasswordsUIController::OnShowManualFallbackForSaving( |
| 179 std::unique_ptr<password_manager::PasswordFormManager> form_manager, |
| 180 bool has_generated_password, |
| 181 bool is_update) { |
| 182 if (wait_for_fallback_) |
| 183 QuitRunLoop(); |
| 184 |
| 185 ManagePasswordsUIController::OnShowManualFallbackForSaving( |
| 186 std::move(form_manager), has_generated_password, is_update); |
| 187 } |
| 188 |
126 bool CustomManagePasswordsUIController::OnChooseCredentials( | 189 bool CustomManagePasswordsUIController::OnChooseCredentials( |
127 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, | 190 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, |
128 const GURL& origin, | 191 const GURL& origin, |
129 const ManagePasswordsState::CredentialsCallback& callback) { | 192 const ManagePasswordsState::CredentialsCallback& callback) { |
130 if (target_state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) { | 193 ProcessStateExpectations(password_manager::ui::CREDENTIAL_REQUEST_STATE); |
131 run_loop_->Quit(); | |
132 run_loop_ = nullptr; | |
133 target_state_ = password_manager::ui::INACTIVE_STATE; | |
134 } | |
135 return ManagePasswordsUIController::OnChooseCredentials( | 194 return ManagePasswordsUIController::OnChooseCredentials( |
136 std::move(local_credentials), origin, callback); | 195 std::move(local_credentials), origin, callback); |
137 } | 196 } |
138 | 197 |
139 void CustomManagePasswordsUIController::OnPasswordAutofilled( | 198 void CustomManagePasswordsUIController::OnPasswordAutofilled( |
140 const std::map<base::string16, const autofill::PasswordForm*>& | 199 const std::map<base::string16, const autofill::PasswordForm*>& |
141 password_form_map, | 200 password_form_map, |
142 const GURL& origin, | 201 const GURL& origin, |
143 const std::vector<const autofill::PasswordForm*>* federated_matches) { | 202 const std::vector<const autofill::PasswordForm*>* federated_matches) { |
144 if (target_state_ == password_manager::ui::MANAGE_STATE) { | 203 ProcessStateExpectations(password_manager::ui::MANAGE_STATE); |
145 run_loop_->Quit(); | |
146 run_loop_ = nullptr; | |
147 target_state_ = password_manager::ui::INACTIVE_STATE; | |
148 } | |
149 return ManagePasswordsUIController::OnPasswordAutofilled( | 204 return ManagePasswordsUIController::OnPasswordAutofilled( |
150 password_form_map, origin, federated_matches); | 205 password_form_map, origin, federated_matches); |
151 } | 206 } |
152 | 207 |
| 208 bool CustomManagePasswordsUIController::IsTargetStateObserved( |
| 209 const password_manager::ui::State target_state, |
| 210 const password_manager::ui::State current_state) const { |
| 211 // This function should not be used for manual fallback expectations. |
| 212 DCHECK(!wait_for_fallback_); |
| 213 |
| 214 bool should_wait_for_automatic_prompt = |
| 215 target_state == password_manager::ui::PENDING_PASSWORD_STATE || |
| 216 target_state == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE; |
| 217 return target_state == current_state && |
| 218 (!should_wait_for_automatic_prompt || was_prompt_automatically_shown_); |
| 219 } |
| 220 |
| 221 void CustomManagePasswordsUIController::ProcessStateExpectations( |
| 222 const password_manager::ui::State current_state) { |
| 223 if (IsTargetStateObserved(target_state_, current_state)) |
| 224 QuitRunLoop(); |
| 225 } |
| 226 |
| 227 void CustomManagePasswordsUIController::QuitRunLoop() { |
| 228 run_loop_->Quit(); |
| 229 run_loop_ = nullptr; |
| 230 wait_for_fallback_ = false; |
| 231 target_state_ = password_manager::ui::INACTIVE_STATE; |
| 232 } |
| 233 |
153 void AddHSTSHostImpl( | 234 void AddHSTSHostImpl( |
154 const scoped_refptr<net::URLRequestContextGetter>& request_context, | 235 const scoped_refptr<net::URLRequestContextGetter>& request_context, |
155 const std::string& host) { | 236 const std::string& host) { |
156 ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); | 237 ASSERT_TRUE(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)); |
157 net::TransportSecurityState* transport_security_state = | 238 net::TransportSecurityState* transport_security_state = |
158 request_context->GetURLRequestContext()->transport_security_state(); | 239 request_context->GetURLRequestContext()->transport_security_state(); |
159 if (!transport_security_state) { | 240 if (!transport_security_state) { |
160 ADD_FAILURE(); | 241 ADD_FAILURE(); |
161 return; | 242 return; |
162 } | 243 } |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
197 } | 278 } |
198 | 279 |
199 void NavigationObserver::Wait() { | 280 void NavigationObserver::Wait() { |
200 run_loop_.Run(); | 281 run_loop_.Run(); |
201 } | 282 } |
202 | 283 |
203 BubbleObserver::BubbleObserver(content::WebContents* web_contents) | 284 BubbleObserver::BubbleObserver(content::WebContents* web_contents) |
204 : passwords_ui_controller_( | 285 : passwords_ui_controller_( |
205 ManagePasswordsUIController::FromWebContents(web_contents)) {} | 286 ManagePasswordsUIController::FromWebContents(web_contents)) {} |
206 | 287 |
207 bool BubbleObserver::IsShowingSavePrompt() const { | 288 bool BubbleObserver::IsSavePromptAvailable() const { |
208 return passwords_ui_controller_->GetState() == | 289 return passwords_ui_controller_->GetState() == |
209 password_manager::ui::PENDING_PASSWORD_STATE; | 290 password_manager::ui::PENDING_PASSWORD_STATE; |
210 } | 291 } |
211 | 292 |
212 bool BubbleObserver::IsShowingUpdatePrompt() const { | 293 bool BubbleObserver::IsUpdatePromptAvailable() const { |
213 return passwords_ui_controller_->GetState() == | 294 return passwords_ui_controller_->GetState() == |
214 password_manager::ui::PENDING_PASSWORD_UPDATE_STATE; | 295 password_manager::ui::PENDING_PASSWORD_UPDATE_STATE; |
215 } | 296 } |
216 | 297 |
| 298 bool BubbleObserver::IsSavePromptShownAutomatically() const { |
| 299 if (!IsSavePromptAvailable()) |
| 300 return false; |
| 301 return static_cast<CustomManagePasswordsUIController*>( |
| 302 passwords_ui_controller_) |
| 303 ->was_prompt_automatically_shown(); |
| 304 } |
| 305 |
| 306 bool BubbleObserver::IsUpdatePromptShownAutomatically() const { |
| 307 if (!IsUpdatePromptAvailable()) |
| 308 return false; |
| 309 return static_cast<CustomManagePasswordsUIController*>( |
| 310 passwords_ui_controller_) |
| 311 ->was_prompt_automatically_shown(); |
| 312 } |
| 313 |
217 void BubbleObserver::Dismiss() const { | 314 void BubbleObserver::Dismiss() const { |
218 passwords_ui_controller_->OnBubbleHidden(); | 315 passwords_ui_controller_->OnBubbleHidden(); |
219 ASSERT_EQ(password_manager::ui::INACTIVE_STATE, | 316 ASSERT_EQ(password_manager::ui::INACTIVE_STATE, |
220 passwords_ui_controller_->GetState()); | 317 passwords_ui_controller_->GetState()); |
221 } | 318 } |
222 | 319 |
223 void BubbleObserver::AcceptSavePrompt() const { | 320 void BubbleObserver::AcceptSavePrompt() const { |
224 ASSERT_TRUE(IsShowingSavePrompt()); | 321 ASSERT_TRUE(IsSavePromptAvailable()); |
225 passwords_ui_controller_->SavePassword( | 322 passwords_ui_controller_->SavePassword( |
226 passwords_ui_controller_->GetPendingPassword().username_value); | 323 passwords_ui_controller_->GetPendingPassword().username_value); |
227 EXPECT_FALSE(IsShowingSavePrompt()); | 324 EXPECT_FALSE(IsSavePromptAvailable()); |
228 } | 325 } |
229 | 326 |
230 void BubbleObserver::AcceptUpdatePrompt( | 327 void BubbleObserver::AcceptUpdatePrompt( |
231 const autofill::PasswordForm& form) const { | 328 const autofill::PasswordForm& form) const { |
232 ASSERT_TRUE(IsShowingUpdatePrompt()); | 329 ASSERT_TRUE(IsUpdatePromptAvailable()); |
233 passwords_ui_controller_->UpdatePassword(form); | 330 passwords_ui_controller_->UpdatePassword(form); |
234 EXPECT_FALSE(IsShowingUpdatePrompt()); | 331 EXPECT_FALSE(IsUpdatePromptAvailable()); |
235 } | 332 } |
236 | 333 |
237 void BubbleObserver::WaitForAccountChooser() const { | 334 void BubbleObserver::WaitForAccountChooser() const { |
238 if (passwords_ui_controller_->GetState() == | |
239 password_manager::ui::CREDENTIAL_REQUEST_STATE) | |
240 return; | |
241 CustomManagePasswordsUIController* controller = | 335 CustomManagePasswordsUIController* controller = |
242 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); | 336 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); |
243 controller->WaitForState(password_manager::ui::CREDENTIAL_REQUEST_STATE); | 337 controller->WaitForState(password_manager::ui::CREDENTIAL_REQUEST_STATE); |
244 } | 338 } |
245 | 339 |
246 void BubbleObserver::WaitForManagementState() const { | 340 void BubbleObserver::WaitForManagementState() const { |
247 if (passwords_ui_controller_->GetState() == | |
248 password_manager::ui::MANAGE_STATE) | |
249 return; | |
250 CustomManagePasswordsUIController* controller = | 341 CustomManagePasswordsUIController* controller = |
251 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); | 342 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); |
252 controller->WaitForState(password_manager::ui::MANAGE_STATE); | 343 controller->WaitForState(password_manager::ui::MANAGE_STATE); |
253 } | 344 } |
254 | 345 |
255 void BubbleObserver::WaitForSavePrompt() const { | 346 void BubbleObserver::WaitForAutomaticSavePrompt() const { |
256 if (passwords_ui_controller_->GetState() == | |
257 password_manager::ui::PENDING_PASSWORD_STATE) | |
258 return; | |
259 CustomManagePasswordsUIController* controller = | 347 CustomManagePasswordsUIController* controller = |
260 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); | 348 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); |
261 controller->WaitForState(password_manager::ui::PENDING_PASSWORD_STATE); | 349 controller->WaitForState(password_manager::ui::PENDING_PASSWORD_STATE); |
262 } | 350 } |
263 | 351 |
| 352 void BubbleObserver::WaitForFallbackForSaving() const { |
| 353 CustomManagePasswordsUIController* controller = |
| 354 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); |
| 355 controller->WaitForFallbackForSaving(); |
| 356 } |
| 357 |
264 PasswordManagerBrowserTestBase::PasswordManagerBrowserTestBase() | 358 PasswordManagerBrowserTestBase::PasswordManagerBrowserTestBase() |
265 : https_test_server_(net::EmbeddedTestServer::TYPE_HTTPS), | 359 : https_test_server_(net::EmbeddedTestServer::TYPE_HTTPS), |
266 web_contents_(nullptr) {} | 360 web_contents_(nullptr) {} |
267 | 361 |
268 PasswordManagerBrowserTestBase::~PasswordManagerBrowserTestBase() = default; | 362 PasswordManagerBrowserTestBase::~PasswordManagerBrowserTestBase() = default; |
269 | 363 |
270 void PasswordManagerBrowserTestBase::SetUpOnMainThread() { | 364 void PasswordManagerBrowserTestBase::SetUpOnMainThread() { |
271 // Use TestPasswordStore to remove a possible race. Normally the | 365 // Use TestPasswordStore to remove a possible race. Normally the |
272 // PasswordStore does its database manipulation on the DB thread, which | 366 // PasswordStore does its database manipulation on the DB thread, which |
273 // creates a possible race during navigation. Specifically the | 367 // creates a possible race during navigation. Specifically the |
(...skipping 219 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
493 | 587 |
494 content::BrowserThread::PostTaskAndReply( | 588 content::BrowserThread::PostTaskAndReply( |
495 content::BrowserThread::IO, FROM_HERE, | 589 content::BrowserThread::IO, FROM_HERE, |
496 base::BindOnce( | 590 base::BindOnce( |
497 &AddHSTSHostImpl, | 591 &AddHSTSHostImpl, |
498 make_scoped_refptr(browser()->profile()->GetRequestContext()), host), | 592 make_scoped_refptr(browser()->profile()->GetRequestContext()), host), |
499 run_loop.QuitClosure()); | 593 run_loop.QuitClosure()); |
500 | 594 |
501 run_loop.Run(); | 595 run_loop.Run(); |
502 } | 596 } |
| 597 |
| 598 void PasswordManagerBrowserTestBase::CheckThatCredentialsStored( |
| 599 const base::string16& username, |
| 600 const base::string16& password) { |
| 601 scoped_refptr<password_manager::TestPasswordStore> password_store = |
| 602 static_cast<password_manager::TestPasswordStore*>( |
| 603 PasswordStoreFactory::GetForProfile( |
| 604 browser()->profile(), ServiceAccessType::IMPLICIT_ACCESS) |
| 605 .get()); |
| 606 auto& passwords_map = password_store->stored_passwords(); |
| 607 ASSERT_EQ(1u, passwords_map.size()); |
| 608 auto& passwords_vector = passwords_map.begin()->second; |
| 609 ASSERT_EQ(1u, passwords_vector.size()); |
| 610 const autofill::PasswordForm& form = passwords_vector[0]; |
| 611 EXPECT_EQ(username, form.username_value); |
| 612 EXPECT_EQ(password, form.password_value); |
| 613 } |
OLD | NEW |