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 bool was_prompt_shown() { return was_prompt_shown_; } |
| 70 |
69 private: | 71 private: |
70 // PasswordsClientUIDelegate: | 72 // PasswordsClientUIDelegate: |
71 void OnPasswordSubmitted( | 73 void OnPasswordSubmitted( |
72 std::unique_ptr<password_manager::PasswordFormManager> form_manager) | 74 std::unique_ptr<password_manager::PasswordFormManager> form_manager) |
73 override; | 75 override; |
| 76 void OnUpdatePasswordSubmitted( |
| 77 std::unique_ptr<password_manager::PasswordFormManager> form_manager) |
| 78 override; |
| 79 void OnShowManualFallbackForSaving( |
| 80 std::unique_ptr<password_manager::PasswordFormManager> form_manager, |
| 81 bool is_update) override; |
74 bool OnChooseCredentials( | 82 bool OnChooseCredentials( |
75 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, | 83 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, |
76 const GURL& origin, | 84 const GURL& origin, |
77 const ManagePasswordsState::CredentialsCallback& callback) override; | 85 const ManagePasswordsState::CredentialsCallback& callback) override; |
78 void OnPasswordAutofilled( | 86 void OnPasswordAutofilled( |
79 const std::map<base::string16, const autofill::PasswordForm*>& | 87 const std::map<base::string16, const autofill::PasswordForm*>& |
80 password_form_map, | 88 password_form_map, |
81 const GURL& origin, | 89 const GURL& origin, |
82 const std::vector<const autofill::PasswordForm*>* federated_matches) | 90 const std::vector<const autofill::PasswordForm*>* federated_matches) |
83 override; | 91 override; |
84 | 92 |
85 // The loop to be stopped when the target state is observed. | 93 // The loop to be stopped when the target state is observed. |
86 base::RunLoop* run_loop_; | 94 base::RunLoop* run_loop_; |
87 | 95 |
88 // The state CustomManagePasswordsUIController is currently waiting for. | 96 // The state CustomManagePasswordsUIController is currently waiting for. |
89 password_manager::ui::State target_state_; | 97 password_manager::ui::State target_state_; |
90 | 98 |
| 99 bool was_prompt_shown_; |
| 100 |
91 DISALLOW_COPY_AND_ASSIGN(CustomManagePasswordsUIController); | 101 DISALLOW_COPY_AND_ASSIGN(CustomManagePasswordsUIController); |
92 }; | 102 }; |
93 | 103 |
94 CustomManagePasswordsUIController::CustomManagePasswordsUIController( | 104 CustomManagePasswordsUIController::CustomManagePasswordsUIController( |
95 content::WebContents* web_contents) | 105 content::WebContents* web_contents) |
96 : ManagePasswordsUIController(web_contents), | 106 : ManagePasswordsUIController(web_contents), |
97 run_loop_(nullptr), | 107 run_loop_(nullptr), |
98 target_state_(password_manager::ui::INACTIVE_STATE) { | 108 target_state_(password_manager::ui::INACTIVE_STATE), |
| 109 was_prompt_shown_(false) { |
99 // Attach CustomManagePasswordsUIController to |web_contents| so the default | 110 // Attach CustomManagePasswordsUIController to |web_contents| so the default |
100 // ManagePasswordsUIController isn't created. | 111 // ManagePasswordsUIController isn't created. |
101 // Do not silently replace an existing ManagePasswordsUIController because it | 112 // Do not silently replace an existing ManagePasswordsUIController because it |
102 // unregisters itself in WebContentsDestroyed(). | 113 // unregisters itself in WebContentsDestroyed(). |
103 EXPECT_FALSE(web_contents->GetUserData(UserDataKey())); | 114 EXPECT_FALSE(web_contents->GetUserData(UserDataKey())); |
104 web_contents->SetUserData(UserDataKey(), base::WrapUnique(this)); | 115 web_contents->SetUserData(UserDataKey(), base::WrapUnique(this)); |
105 } | 116 } |
106 | 117 |
107 void CustomManagePasswordsUIController::WaitForState( | 118 void CustomManagePasswordsUIController::WaitForState( |
108 password_manager::ui::State target_state) { | 119 password_manager::ui::State target_state) { |
109 base::RunLoop run_loop; | 120 base::RunLoop run_loop; |
110 target_state_ = target_state; | 121 target_state_ = target_state; |
111 run_loop_ = &run_loop; | 122 run_loop_ = &run_loop; |
112 run_loop_->Run(); | 123 run_loop_->Run(); |
113 } | 124 } |
114 | 125 |
115 void CustomManagePasswordsUIController::OnPasswordSubmitted( | 126 void CustomManagePasswordsUIController::OnPasswordSubmitted( |
116 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { | 127 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { |
117 if (target_state_ == password_manager::ui::PENDING_PASSWORD_STATE) { | 128 if (target_state_ == password_manager::ui::PENDING_PASSWORD_STATE) { |
118 run_loop_->Quit(); | 129 run_loop_->Quit(); |
119 run_loop_ = nullptr; | 130 run_loop_ = nullptr; |
120 target_state_ = password_manager::ui::INACTIVE_STATE; | 131 target_state_ = password_manager::ui::INACTIVE_STATE; |
121 } | 132 } |
| 133 was_prompt_shown_ = true; |
122 return ManagePasswordsUIController::OnPasswordSubmitted( | 134 return ManagePasswordsUIController::OnPasswordSubmitted( |
123 std::move(form_manager)); | 135 std::move(form_manager)); |
124 } | 136 } |
125 | 137 |
| 138 void CustomManagePasswordsUIController::OnUpdatePasswordSubmitted( |
| 139 std::unique_ptr<password_manager::PasswordFormManager> form_manager) { |
| 140 was_prompt_shown_ = true; |
| 141 return ManagePasswordsUIController::OnUpdatePasswordSubmitted( |
| 142 std::move(form_manager)); |
| 143 } |
| 144 |
| 145 void CustomManagePasswordsUIController::OnShowManualFallbackForSaving( |
| 146 std::unique_ptr<password_manager::PasswordFormManager> form_manager, |
| 147 bool is_update) { |
| 148 if (target_state_ == password_manager::ui::PENDING_PASSWORD_STATE) { |
| 149 run_loop_->Quit(); |
| 150 run_loop_ = nullptr; |
| 151 target_state_ = password_manager::ui::INACTIVE_STATE; |
| 152 } |
| 153 ManagePasswordsUIController::OnShowManualFallbackForSaving( |
| 154 std::move(form_manager), is_update); |
| 155 } |
| 156 |
126 bool CustomManagePasswordsUIController::OnChooseCredentials( | 157 bool CustomManagePasswordsUIController::OnChooseCredentials( |
127 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, | 158 std::vector<std::unique_ptr<autofill::PasswordForm>> local_credentials, |
128 const GURL& origin, | 159 const GURL& origin, |
129 const ManagePasswordsState::CredentialsCallback& callback) { | 160 const ManagePasswordsState::CredentialsCallback& callback) { |
130 if (target_state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) { | 161 if (target_state_ == password_manager::ui::CREDENTIAL_REQUEST_STATE) { |
131 run_loop_->Quit(); | 162 run_loop_->Quit(); |
132 run_loop_ = nullptr; | 163 run_loop_ = nullptr; |
133 target_state_ = password_manager::ui::INACTIVE_STATE; | 164 target_state_ = password_manager::ui::INACTIVE_STATE; |
134 } | 165 } |
135 return ManagePasswordsUIController::OnChooseCredentials( | 166 return ManagePasswordsUIController::OnChooseCredentials( |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
197 } | 228 } |
198 | 229 |
199 void NavigationObserver::Wait() { | 230 void NavigationObserver::Wait() { |
200 run_loop_.Run(); | 231 run_loop_.Run(); |
201 } | 232 } |
202 | 233 |
203 BubbleObserver::BubbleObserver(content::WebContents* web_contents) | 234 BubbleObserver::BubbleObserver(content::WebContents* web_contents) |
204 : passwords_ui_controller_( | 235 : passwords_ui_controller_( |
205 ManagePasswordsUIController::FromWebContents(web_contents)) {} | 236 ManagePasswordsUIController::FromWebContents(web_contents)) {} |
206 | 237 |
207 bool BubbleObserver::IsShowingSavePrompt() const { | 238 bool BubbleObserver::IsSavePromptAvailable() const { |
208 return passwords_ui_controller_->GetState() == | 239 return passwords_ui_controller_->GetState() == |
209 password_manager::ui::PENDING_PASSWORD_STATE; | 240 password_manager::ui::PENDING_PASSWORD_STATE; |
210 } | 241 } |
211 | 242 |
212 bool BubbleObserver::IsShowingUpdatePrompt() const { | 243 bool BubbleObserver::IsUpdatePromptAvailable() const { |
213 return passwords_ui_controller_->GetState() == | 244 return passwords_ui_controller_->GetState() == |
214 password_manager::ui::PENDING_PASSWORD_UPDATE_STATE; | 245 password_manager::ui::PENDING_PASSWORD_UPDATE_STATE; |
215 } | 246 } |
216 | 247 |
| 248 bool BubbleObserver::WasSavePromptShown() const { |
| 249 if (!IsSavePromptAvailable()) |
| 250 return false; |
| 251 return static_cast<CustomManagePasswordsUIController*>( |
| 252 passwords_ui_controller_) |
| 253 ->was_prompt_shown(); |
| 254 } |
| 255 |
| 256 bool BubbleObserver::WasUpdatePromptShown() const { |
| 257 if (!IsUpdatePromptAvailable()) |
| 258 return false; |
| 259 return static_cast<CustomManagePasswordsUIController*>( |
| 260 passwords_ui_controller_) |
| 261 ->was_prompt_shown(); |
| 262 } |
| 263 |
217 void BubbleObserver::Dismiss() const { | 264 void BubbleObserver::Dismiss() const { |
218 passwords_ui_controller_->OnBubbleHidden(); | 265 passwords_ui_controller_->OnBubbleHidden(); |
219 ASSERT_EQ(password_manager::ui::INACTIVE_STATE, | 266 ASSERT_EQ(password_manager::ui::INACTIVE_STATE, |
220 passwords_ui_controller_->GetState()); | 267 passwords_ui_controller_->GetState()); |
221 } | 268 } |
222 | 269 |
223 void BubbleObserver::AcceptSavePrompt() const { | 270 void BubbleObserver::AcceptSavePrompt() const { |
224 ASSERT_TRUE(IsShowingSavePrompt()); | 271 ASSERT_TRUE(WasSavePromptShown()); |
225 passwords_ui_controller_->SavePassword( | 272 passwords_ui_controller_->SavePassword( |
226 passwords_ui_controller_->GetPendingPassword().username_value); | 273 passwords_ui_controller_->GetPendingPassword().username_value); |
227 EXPECT_FALSE(IsShowingSavePrompt()); | 274 EXPECT_FALSE(IsSavePromptAvailable()); |
| 275 } |
| 276 |
| 277 void BubbleObserver::OpenAndAcceptSavePrompt() const { |
| 278 ASSERT_TRUE(IsSavePromptAvailable()); |
| 279 passwords_ui_controller_->SavePassword( |
| 280 passwords_ui_controller_->GetPendingPassword().username_value); |
| 281 EXPECT_FALSE(IsSavePromptAvailable()); |
228 } | 282 } |
229 | 283 |
230 void BubbleObserver::AcceptUpdatePrompt( | 284 void BubbleObserver::AcceptUpdatePrompt( |
231 const autofill::PasswordForm& form) const { | 285 const autofill::PasswordForm& form) const { |
232 ASSERT_TRUE(IsShowingUpdatePrompt()); | 286 ASSERT_TRUE(WasUpdatePromptShown()); |
233 passwords_ui_controller_->UpdatePassword(form); | 287 passwords_ui_controller_->UpdatePassword(form); |
234 EXPECT_FALSE(IsShowingUpdatePrompt()); | 288 EXPECT_FALSE(IsUpdatePromptAvailable()); |
235 } | 289 } |
236 | 290 |
237 void BubbleObserver::WaitForAccountChooser() const { | 291 void BubbleObserver::WaitForAccountChooser() const { |
238 if (passwords_ui_controller_->GetState() == | 292 if (passwords_ui_controller_->GetState() == |
239 password_manager::ui::CREDENTIAL_REQUEST_STATE) | 293 password_manager::ui::CREDENTIAL_REQUEST_STATE) |
240 return; | 294 return; |
241 CustomManagePasswordsUIController* controller = | 295 CustomManagePasswordsUIController* controller = |
242 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); | 296 static_cast<CustomManagePasswordsUIController*>(passwords_ui_controller_); |
243 controller->WaitForState(password_manager::ui::CREDENTIAL_REQUEST_STATE); | 297 controller->WaitForState(password_manager::ui::CREDENTIAL_REQUEST_STATE); |
244 } | 298 } |
(...skipping 248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
493 | 547 |
494 content::BrowserThread::PostTaskAndReply( | 548 content::BrowserThread::PostTaskAndReply( |
495 content::BrowserThread::IO, FROM_HERE, | 549 content::BrowserThread::IO, FROM_HERE, |
496 base::BindOnce( | 550 base::BindOnce( |
497 &AddHSTSHostImpl, | 551 &AddHSTSHostImpl, |
498 make_scoped_refptr(browser()->profile()->GetRequestContext()), host), | 552 make_scoped_refptr(browser()->profile()->GetRequestContext()), host), |
499 run_loop.QuitClosure()); | 553 run_loop.QuitClosure()); |
500 | 554 |
501 run_loop.Run(); | 555 run_loop.Run(); |
502 } | 556 } |
| 557 |
| 558 void PasswordManagerBrowserTestBase::CheckThatCredentialsStored( |
| 559 password_manager::TestPasswordStore* password_store, |
| 560 const base::string16& username, |
| 561 const base::string16& password) { |
| 562 auto& passwords_map = password_store->stored_passwords(); |
| 563 ASSERT_EQ(1u, passwords_map.size()); |
| 564 auto& passwords_vector = passwords_map.begin()->second; |
| 565 ASSERT_EQ(1u, passwords_vector.size()); |
| 566 const autofill::PasswordForm& form = passwords_vector[0]; |
| 567 EXPECT_EQ(username, form.username_value); |
| 568 EXPECT_EQ(password, form.password_value); |
| 569 } |
OLD | NEW |