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