Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(254)

Side by Side Diff: components/password_manager/core/browser/login_database_unittest.cc

Issue 838453003: Open the LoginDatabase on the DB thread, not the UI thread. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix nits from vabr@. Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 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 "components/password_manager/core/browser/login_database.h" 5 #include "components/password_manager/core/browser/login_database.h"
6 6
7 #include "base/basictypes.h" 7 #include "base/basictypes.h"
8 #include "base/files/file_util.h" 8 #include "base/files/file_util.h"
9 #include "base/files/scoped_temp_dir.h" 9 #include "base/files/scoped_temp_dir.h"
10 #include "base/memory/scoped_ptr.h"
10 #include "base/memory/scoped_vector.h" 11 #include "base/memory/scoped_vector.h"
11 #include "base/path_service.h" 12 #include "base/path_service.h"
12 #include "base/strings/string_number_conversions.h" 13 #include "base/strings/string_number_conversions.h"
13 #include "base/strings/utf_string_conversions.h" 14 #include "base/strings/utf_string_conversions.h"
14 #include "base/test/histogram_tester.h" 15 #include "base/test/histogram_tester.h"
15 #include "base/time/time.h" 16 #include "base/time/time.h"
16 #include "components/autofill/core/common/password_form.h" 17 #include "components/autofill/core/common/password_form.h"
17 #include "components/password_manager/core/browser/psl_matching_helper.h" 18 #include "components/password_manager/core/browser/psl_matching_helper.h"
18 #include "sql/connection.h" 19 #include "sql/connection.h"
19 #include "sql/statement.h" 20 #include "sql/statement.h"
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
72 // Serialization routines for vectors implemented in login_database.cc. 73 // Serialization routines for vectors implemented in login_database.cc.
73 Pickle SerializeVector(const std::vector<base::string16>& vec); 74 Pickle SerializeVector(const std::vector<base::string16>& vec);
74 std::vector<base::string16> DeserializeVector(const Pickle& pickle); 75 std::vector<base::string16> DeserializeVector(const Pickle& pickle);
75 76
76 class LoginDatabaseTest : public testing::Test { 77 class LoginDatabaseTest : public testing::Test {
77 protected: 78 protected:
78 void SetUp() override { 79 void SetUp() override {
79 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 80 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
80 file_ = temp_dir_.path().AppendASCII("TestMetadataStoreMacDatabase"); 81 file_ = temp_dir_.path().AppendASCII("TestMetadataStoreMacDatabase");
81 82
82 ASSERT_TRUE(db_.Init(file_)); 83 db_.reset(new LoginDatabase(file_));
84 ASSERT_TRUE(db_->Init());
83 } 85 }
84 86
87 LoginDatabase& db() { return *db_; }
88
85 void TestNonHTMLFormPSLMatching(const PasswordForm::Scheme& scheme) { 89 void TestNonHTMLFormPSLMatching(const PasswordForm::Scheme& scheme) {
86 ScopedVector<PasswordForm> result; 90 ScopedVector<PasswordForm> result;
87 91
88 base::Time now = base::Time::Now(); 92 base::Time now = base::Time::Now();
89 93
90 // Simple non-html auth form. 94 // Simple non-html auth form.
91 PasswordForm non_html_auth; 95 PasswordForm non_html_auth;
92 non_html_auth.origin = GURL("http://example.com"); 96 non_html_auth.origin = GURL("http://example.com");
93 non_html_auth.username_value = ASCIIToUTF16("test@gmail.com"); 97 non_html_auth.username_value = ASCIIToUTF16("test@gmail.com");
94 non_html_auth.password_value = ASCIIToUTF16("test"); 98 non_html_auth.password_value = ASCIIToUTF16("test");
95 non_html_auth.signon_realm = "http://example.com/Realm"; 99 non_html_auth.signon_realm = "http://example.com/Realm";
96 non_html_auth.scheme = scheme; 100 non_html_auth.scheme = scheme;
97 non_html_auth.date_created = now; 101 non_html_auth.date_created = now;
98 102
99 // Simple password form. 103 // Simple password form.
100 PasswordForm html_form(non_html_auth); 104 PasswordForm html_form(non_html_auth);
101 html_form.action = GURL("http://example.com/login"); 105 html_form.action = GURL("http://example.com/login");
102 html_form.username_element = ASCIIToUTF16("username"); 106 html_form.username_element = ASCIIToUTF16("username");
103 html_form.username_value = ASCIIToUTF16("test2@gmail.com"); 107 html_form.username_value = ASCIIToUTF16("test2@gmail.com");
104 html_form.password_element = ASCIIToUTF16("password"); 108 html_form.password_element = ASCIIToUTF16("password");
105 html_form.submit_element = ASCIIToUTF16(""); 109 html_form.submit_element = ASCIIToUTF16("");
106 html_form.signon_realm = "http://example.com/"; 110 html_form.signon_realm = "http://example.com/";
107 html_form.scheme = PasswordForm::SCHEME_HTML; 111 html_form.scheme = PasswordForm::SCHEME_HTML;
108 html_form.date_created = now; 112 html_form.date_created = now;
109 113
110 // Add them and make sure they are there. 114 // Add them and make sure they are there.
111 EXPECT_EQ(AddChangeForForm(non_html_auth), db_.AddLogin(non_html_auth)); 115 EXPECT_EQ(AddChangeForForm(non_html_auth), db().AddLogin(non_html_auth));
112 EXPECT_EQ(AddChangeForForm(html_form), db_.AddLogin(html_form)); 116 EXPECT_EQ(AddChangeForForm(html_form), db().AddLogin(html_form));
113 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 117 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
114 EXPECT_EQ(2U, result.size()); 118 EXPECT_EQ(2U, result.size());
115 result.clear(); 119 result.clear();
116 120
117 PasswordForm second_non_html_auth(non_html_auth); 121 PasswordForm second_non_html_auth(non_html_auth);
118 second_non_html_auth.origin = GURL("http://second.example.com"); 122 second_non_html_auth.origin = GURL("http://second.example.com");
119 second_non_html_auth.signon_realm = "http://second.example.com/Realm"; 123 second_non_html_auth.signon_realm = "http://second.example.com/Realm";
120 124
121 // This shouldn't match anything. 125 // This shouldn't match anything.
122 EXPECT_TRUE(db_.GetLogins(second_non_html_auth, &result.get())); 126 EXPECT_TRUE(db().GetLogins(second_non_html_auth, &result.get()));
123 EXPECT_EQ(0U, result.size()); 127 EXPECT_EQ(0U, result.size());
124 128
125 // non-html auth still matches against itself. 129 // non-html auth still matches against itself.
126 EXPECT_TRUE(db_.GetLogins(non_html_auth, &result.get())); 130 EXPECT_TRUE(db().GetLogins(non_html_auth, &result.get()));
127 ASSERT_EQ(1U, result.size()); 131 ASSERT_EQ(1U, result.size());
128 EXPECT_EQ(result[0]->signon_realm, "http://example.com/Realm"); 132 EXPECT_EQ(result[0]->signon_realm, "http://example.com/Realm");
129 133
130 // Clear state. 134 // Clear state.
131 db_.RemoveLoginsCreatedBetween(now, base::Time()); 135 db().RemoveLoginsCreatedBetween(now, base::Time());
132 } 136 }
133 137
134 // Checks that a form of a given |scheme|, once stored, can be successfully 138 // Checks that a form of a given |scheme|, once stored, can be successfully
135 // retrieved from the database. 139 // retrieved from the database.
136 void TestRetrievingIPAddress(const PasswordForm::Scheme& scheme) { 140 void TestRetrievingIPAddress(const PasswordForm::Scheme& scheme) {
137 SCOPED_TRACE(testing::Message() << "scheme = " << scheme); 141 SCOPED_TRACE(testing::Message() << "scheme = " << scheme);
138 ScopedVector<PasswordForm> result; 142 ScopedVector<PasswordForm> result;
139 143
140 base::Time now = base::Time::Now(); 144 base::Time now = base::Time::Now();
141 std::string origin("http://56.7.8.90"); 145 std::string origin("http://56.7.8.90");
142 146
143 PasswordForm ip_form; 147 PasswordForm ip_form;
144 ip_form.origin = GURL(origin); 148 ip_form.origin = GURL(origin);
145 ip_form.username_value = ASCIIToUTF16("test@gmail.com"); 149 ip_form.username_value = ASCIIToUTF16("test@gmail.com");
146 ip_form.password_value = ASCIIToUTF16("test"); 150 ip_form.password_value = ASCIIToUTF16("test");
147 ip_form.signon_realm = origin; 151 ip_form.signon_realm = origin;
148 ip_form.scheme = scheme; 152 ip_form.scheme = scheme;
149 ip_form.date_created = now; 153 ip_form.date_created = now;
150 154
151 EXPECT_EQ(AddChangeForForm(ip_form), db_.AddLogin(ip_form)); 155 EXPECT_EQ(AddChangeForForm(ip_form), db().AddLogin(ip_form));
152 EXPECT_TRUE(db_.GetLogins(ip_form, &result.get())); 156 EXPECT_TRUE(db().GetLogins(ip_form, &result.get()));
153 ASSERT_EQ(1U, result.size()); 157 ASSERT_EQ(1U, result.size());
154 EXPECT_EQ(result[0]->signon_realm, origin); 158 EXPECT_EQ(result[0]->signon_realm, origin);
155 159
156 // Clear state. 160 // Clear state.
157 db_.RemoveLoginsCreatedBetween(now, base::Time()); 161 db().RemoveLoginsCreatedBetween(now, base::Time());
158 } 162 }
159 163
160 base::ScopedTempDir temp_dir_; 164 base::ScopedTempDir temp_dir_;
161 base::FilePath file_; 165 base::FilePath file_;
162 LoginDatabase db_; 166 scoped_ptr<LoginDatabase> db_;
163 }; 167 };
164 168
165 TEST_F(LoginDatabaseTest, Logins) { 169 TEST_F(LoginDatabaseTest, Logins) {
166 std::vector<PasswordForm*> result; 170 std::vector<PasswordForm*> result;
167 171
168 // Verify the database is empty. 172 // Verify the database is empty.
169 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 173 EXPECT_TRUE(db().GetAutofillableLogins(&result));
170 EXPECT_EQ(0U, result.size()); 174 EXPECT_EQ(0U, result.size());
171 175
172 // Example password form. 176 // Example password form.
173 PasswordForm form; 177 PasswordForm form;
174 GenerateExamplePasswordForm(&form); 178 GenerateExamplePasswordForm(&form);
175 179
176 // Add it and make sure it is there and that all the fields were retrieved 180 // Add it and make sure it is there and that all the fields were retrieved
177 // correctly. 181 // correctly.
178 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 182 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
179 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 183 EXPECT_TRUE(db().GetAutofillableLogins(&result));
180 ASSERT_EQ(1U, result.size()); 184 ASSERT_EQ(1U, result.size());
181 FormsAreEqual(form, *result[0]); 185 FormsAreEqual(form, *result[0]);
182 delete result[0]; 186 delete result[0];
183 result.clear(); 187 result.clear();
184 188
185 // Match against an exact copy. 189 // Match against an exact copy.
186 EXPECT_TRUE(db_.GetLogins(form, &result)); 190 EXPECT_TRUE(db().GetLogins(form, &result));
187 ASSERT_EQ(1U, result.size()); 191 ASSERT_EQ(1U, result.size());
188 FormsAreEqual(form, *result[0]); 192 FormsAreEqual(form, *result[0]);
189 delete result[0]; 193 delete result[0];
190 result.clear(); 194 result.clear();
191 195
192 // The example site changes... 196 // The example site changes...
193 PasswordForm form2(form); 197 PasswordForm form2(form);
194 form2.origin = GURL("http://www.google.com/new/accounts/LoginAuth"); 198 form2.origin = GURL("http://www.google.com/new/accounts/LoginAuth");
195 form2.submit_element = ASCIIToUTF16("reallySignIn"); 199 form2.submit_element = ASCIIToUTF16("reallySignIn");
196 200
197 // Match against an inexact copy 201 // Match against an inexact copy
198 EXPECT_TRUE(db_.GetLogins(form2, &result)); 202 EXPECT_TRUE(db().GetLogins(form2, &result));
199 EXPECT_EQ(1U, result.size()); 203 EXPECT_EQ(1U, result.size());
200 delete result[0]; 204 delete result[0];
201 result.clear(); 205 result.clear();
202 206
203 // Uh oh, the site changed origin & action URLs all at once! 207 // Uh oh, the site changed origin & action URLs all at once!
204 PasswordForm form3(form2); 208 PasswordForm form3(form2);
205 form3.action = GURL("http://www.google.com/new/accounts/Login"); 209 form3.action = GURL("http://www.google.com/new/accounts/Login");
206 210
207 // signon_realm is the same, should match. 211 // signon_realm is the same, should match.
208 EXPECT_TRUE(db_.GetLogins(form3, &result)); 212 EXPECT_TRUE(db().GetLogins(form3, &result));
209 EXPECT_EQ(1U, result.size()); 213 EXPECT_EQ(1U, result.size());
210 delete result[0]; 214 delete result[0];
211 result.clear(); 215 result.clear();
212 216
213 // Imagine the site moves to a secure server for login. 217 // Imagine the site moves to a secure server for login.
214 PasswordForm form4(form3); 218 PasswordForm form4(form3);
215 form4.signon_realm = "https://www.google.com/"; 219 form4.signon_realm = "https://www.google.com/";
216 form4.ssl_valid = true; 220 form4.ssl_valid = true;
217 221
218 // We have only an http record, so no match for this. 222 // We have only an http record, so no match for this.
219 EXPECT_TRUE(db_.GetLogins(form4, &result)); 223 EXPECT_TRUE(db().GetLogins(form4, &result));
220 EXPECT_EQ(0U, result.size()); 224 EXPECT_EQ(0U, result.size());
221 225
222 // Let's imagine the user logs into the secure site. 226 // Let's imagine the user logs into the secure site.
223 EXPECT_EQ(AddChangeForForm(form4), db_.AddLogin(form4)); 227 EXPECT_EQ(AddChangeForForm(form4), db().AddLogin(form4));
224 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 228 EXPECT_TRUE(db().GetAutofillableLogins(&result));
225 EXPECT_EQ(2U, result.size()); 229 EXPECT_EQ(2U, result.size());
226 delete result[0]; 230 delete result[0];
227 delete result[1]; 231 delete result[1];
228 result.clear(); 232 result.clear();
229 233
230 // Now the match works 234 // Now the match works
231 EXPECT_TRUE(db_.GetLogins(form4, &result)); 235 EXPECT_TRUE(db().GetLogins(form4, &result));
232 EXPECT_EQ(1U, result.size()); 236 EXPECT_EQ(1U, result.size());
233 delete result[0]; 237 delete result[0];
234 result.clear(); 238 result.clear();
235 239
236 // The user chose to forget the original but not the new. 240 // The user chose to forget the original but not the new.
237 EXPECT_TRUE(db_.RemoveLogin(form)); 241 EXPECT_TRUE(db().RemoveLogin(form));
238 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 242 EXPECT_TRUE(db().GetAutofillableLogins(&result));
239 EXPECT_EQ(1U, result.size()); 243 EXPECT_EQ(1U, result.size());
240 delete result[0]; 244 delete result[0];
241 result.clear(); 245 result.clear();
242 246
243 // The old form wont match the new site (http vs https). 247 // The old form wont match the new site (http vs https).
244 EXPECT_TRUE(db_.GetLogins(form, &result)); 248 EXPECT_TRUE(db().GetLogins(form, &result));
245 EXPECT_EQ(0U, result.size()); 249 EXPECT_EQ(0U, result.size());
246 250
247 // The user's request for the HTTPS site is intercepted 251 // The user's request for the HTTPS site is intercepted
248 // by an attacker who presents an invalid SSL cert. 252 // by an attacker who presents an invalid SSL cert.
249 PasswordForm form5(form4); 253 PasswordForm form5(form4);
250 form5.ssl_valid = 0; 254 form5.ssl_valid = 0;
251 255
252 // It will match in this case. 256 // It will match in this case.
253 EXPECT_TRUE(db_.GetLogins(form5, &result)); 257 EXPECT_TRUE(db().GetLogins(form5, &result));
254 EXPECT_EQ(1U, result.size()); 258 EXPECT_EQ(1U, result.size());
255 delete result[0]; 259 delete result[0];
256 result.clear(); 260 result.clear();
257 261
258 // User changes his password. 262 // User changes his password.
259 PasswordForm form6(form5); 263 PasswordForm form6(form5);
260 form6.password_value = ASCIIToUTF16("test6"); 264 form6.password_value = ASCIIToUTF16("test6");
261 form6.preferred = true; 265 form6.preferred = true;
262 266
263 // We update, and check to make sure it matches the 267 // We update, and check to make sure it matches the
264 // old form, and there is only one record. 268 // old form, and there is only one record.
265 EXPECT_EQ(UpdateChangeForForm(form6), db_.UpdateLogin(form6)); 269 EXPECT_EQ(UpdateChangeForForm(form6), db().UpdateLogin(form6));
266 // matches 270 // matches
267 EXPECT_TRUE(db_.GetLogins(form5, &result)); 271 EXPECT_TRUE(db().GetLogins(form5, &result));
268 EXPECT_EQ(1U, result.size()); 272 EXPECT_EQ(1U, result.size());
269 delete result[0]; 273 delete result[0];
270 result.clear(); 274 result.clear();
271 // Only one record. 275 // Only one record.
272 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 276 EXPECT_TRUE(db().GetAutofillableLogins(&result));
273 EXPECT_EQ(1U, result.size()); 277 EXPECT_EQ(1U, result.size());
274 // Password element was updated. 278 // Password element was updated.
275 #if defined(OS_MACOSX) && !defined(OS_IOS) 279 #if defined(OS_MACOSX) && !defined(OS_IOS)
276 // On the Mac we should never be storing passwords in the database. 280 // On the Mac we should never be storing passwords in the database.
277 EXPECT_EQ(base::string16(), result[0]->password_value); 281 EXPECT_EQ(base::string16(), result[0]->password_value);
278 #else 282 #else
279 EXPECT_EQ(form6.password_value, result[0]->password_value); 283 EXPECT_EQ(form6.password_value, result[0]->password_value);
280 #endif 284 #endif
281 // Preferred login. 285 // Preferred login.
282 EXPECT_TRUE(form6.preferred); 286 EXPECT_TRUE(form6.preferred);
283 delete result[0]; 287 delete result[0];
284 result.clear(); 288 result.clear();
285 289
286 // Make sure everything can disappear. 290 // Make sure everything can disappear.
287 EXPECT_TRUE(db_.RemoveLogin(form4)); 291 EXPECT_TRUE(db().RemoveLogin(form4));
288 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 292 EXPECT_TRUE(db().GetAutofillableLogins(&result));
289 EXPECT_EQ(0U, result.size()); 293 EXPECT_EQ(0U, result.size());
290 } 294 }
291 295
292 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatching) { 296 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatching) {
293 std::vector<PasswordForm*> result; 297 std::vector<PasswordForm*> result;
294 298
295 // Verify the database is empty. 299 // Verify the database is empty.
296 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 300 EXPECT_TRUE(db().GetAutofillableLogins(&result));
297 EXPECT_EQ(0U, result.size()); 301 EXPECT_EQ(0U, result.size());
298 302
299 // Example password form. 303 // Example password form.
300 PasswordForm form; 304 PasswordForm form;
301 form.origin = GURL("https://foo.com/"); 305 form.origin = GURL("https://foo.com/");
302 form.action = GURL("https://foo.com/login"); 306 form.action = GURL("https://foo.com/login");
303 form.username_element = ASCIIToUTF16("username"); 307 form.username_element = ASCIIToUTF16("username");
304 form.username_value = ASCIIToUTF16("test@gmail.com"); 308 form.username_value = ASCIIToUTF16("test@gmail.com");
305 form.password_element = ASCIIToUTF16("password"); 309 form.password_element = ASCIIToUTF16("password");
306 form.password_value = ASCIIToUTF16("test"); 310 form.password_value = ASCIIToUTF16("test");
307 form.submit_element = ASCIIToUTF16(""); 311 form.submit_element = ASCIIToUTF16("");
308 form.signon_realm = "https://foo.com/"; 312 form.signon_realm = "https://foo.com/";
309 form.ssl_valid = true; 313 form.ssl_valid = true;
310 form.preferred = false; 314 form.preferred = false;
311 form.scheme = PasswordForm::SCHEME_HTML; 315 form.scheme = PasswordForm::SCHEME_HTML;
312 316
313 // Add it and make sure it is there. 317 // Add it and make sure it is there.
314 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 318 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
315 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 319 EXPECT_TRUE(db().GetAutofillableLogins(&result));
316 EXPECT_EQ(1U, result.size()); 320 EXPECT_EQ(1U, result.size());
317 delete result[0]; 321 delete result[0];
318 result.clear(); 322 result.clear();
319 323
320 // Match against an exact copy. 324 // Match against an exact copy.
321 EXPECT_TRUE(db_.GetLogins(form, &result)); 325 EXPECT_TRUE(db().GetLogins(form, &result));
322 EXPECT_EQ(1U, result.size()); 326 EXPECT_EQ(1U, result.size());
323 delete result[0]; 327 delete result[0];
324 result.clear(); 328 result.clear();
325 329
326 // We go to the mobile site. 330 // We go to the mobile site.
327 PasswordForm form2(form); 331 PasswordForm form2(form);
328 form2.origin = GURL("https://mobile.foo.com/"); 332 form2.origin = GURL("https://mobile.foo.com/");
329 form2.action = GURL("https://mobile.foo.com/login"); 333 form2.action = GURL("https://mobile.foo.com/login");
330 form2.signon_realm = "https://mobile.foo.com/"; 334 form2.signon_realm = "https://mobile.foo.com/";
331 335
332 // Match against the mobile site. 336 // Match against the mobile site.
333 EXPECT_TRUE(db_.GetLogins(form2, &result)); 337 EXPECT_TRUE(db().GetLogins(form2, &result));
334 EXPECT_EQ(1U, result.size()); 338 EXPECT_EQ(1U, result.size());
335 EXPECT_EQ("https://mobile.foo.com/", result[0]->signon_realm); 339 EXPECT_EQ("https://mobile.foo.com/", result[0]->signon_realm);
336 EXPECT_EQ("https://foo.com/", result[0]->original_signon_realm); 340 EXPECT_EQ("https://foo.com/", result[0]->original_signon_realm);
337 341
338 // Try to remove PSL matched form 342 // Try to remove PSL matched form
339 EXPECT_FALSE(db_.RemoveLogin(*result[0])); 343 EXPECT_FALSE(db().RemoveLogin(*result[0]));
340 delete result[0]; 344 delete result[0];
341 result.clear(); 345 result.clear();
342 // Ensure that the original form is still there 346 // Ensure that the original form is still there
343 EXPECT_TRUE(db_.GetLogins(form, &result)); 347 EXPECT_TRUE(db().GetLogins(form, &result));
344 EXPECT_EQ(1U, result.size()); 348 EXPECT_EQ(1U, result.size());
345 delete result[0]; 349 delete result[0];
346 result.clear(); 350 result.clear();
347 } 351 }
348 352
349 TEST_F(LoginDatabaseTest, TestPublicSuffixDisabledForNonHTMLForms) { 353 TEST_F(LoginDatabaseTest, TestPublicSuffixDisabledForNonHTMLForms) {
350 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_BASIC); 354 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_BASIC);
351 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_DIGEST); 355 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_DIGEST);
352 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_OTHER); 356 TestNonHTMLFormPSLMatching(PasswordForm::SCHEME_OTHER);
353 } 357 }
(...skipping 11 matching lines...) Expand all
365 } 369 }
366 370
367 TEST_F(LoginDatabaseTest, TestIPAddressMatches_other) { 371 TEST_F(LoginDatabaseTest, TestIPAddressMatches_other) {
368 TestRetrievingIPAddress(PasswordForm::SCHEME_OTHER); 372 TestRetrievingIPAddress(PasswordForm::SCHEME_OTHER);
369 } 373 }
370 374
371 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingShouldMatchingApply) { 375 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingShouldMatchingApply) {
372 std::vector<PasswordForm*> result; 376 std::vector<PasswordForm*> result;
373 377
374 // Verify the database is empty. 378 // Verify the database is empty.
375 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 379 EXPECT_TRUE(db().GetAutofillableLogins(&result));
376 EXPECT_EQ(0U, result.size()); 380 EXPECT_EQ(0U, result.size());
377 381
378 // Example password form. 382 // Example password form.
379 PasswordForm form; 383 PasswordForm form;
380 form.origin = GURL("https://accounts.google.com/"); 384 form.origin = GURL("https://accounts.google.com/");
381 form.action = GURL("https://accounts.google.com/login"); 385 form.action = GURL("https://accounts.google.com/login");
382 form.username_element = ASCIIToUTF16("username"); 386 form.username_element = ASCIIToUTF16("username");
383 form.username_value = ASCIIToUTF16("test@gmail.com"); 387 form.username_value = ASCIIToUTF16("test@gmail.com");
384 form.password_element = ASCIIToUTF16("password"); 388 form.password_element = ASCIIToUTF16("password");
385 form.password_value = ASCIIToUTF16("test"); 389 form.password_value = ASCIIToUTF16("test");
386 form.submit_element = ASCIIToUTF16(""); 390 form.submit_element = ASCIIToUTF16("");
387 form.signon_realm = "https://accounts.google.com/"; 391 form.signon_realm = "https://accounts.google.com/";
388 form.ssl_valid = true; 392 form.ssl_valid = true;
389 form.preferred = false; 393 form.preferred = false;
390 form.scheme = PasswordForm::SCHEME_HTML; 394 form.scheme = PasswordForm::SCHEME_HTML;
391 395
392 // Add it and make sure it is there. 396 // Add it and make sure it is there.
393 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 397 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
394 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 398 EXPECT_TRUE(db().GetAutofillableLogins(&result));
395 EXPECT_EQ(1U, result.size()); 399 EXPECT_EQ(1U, result.size());
396 delete result[0]; 400 delete result[0];
397 result.clear(); 401 result.clear();
398 402
399 // Match against an exact copy. 403 // Match against an exact copy.
400 EXPECT_TRUE(db_.GetLogins(form, &result)); 404 EXPECT_TRUE(db().GetLogins(form, &result));
401 EXPECT_EQ(1U, result.size()); 405 EXPECT_EQ(1U, result.size());
402 delete result[0]; 406 delete result[0];
403 result.clear(); 407 result.clear();
404 408
405 // We go to a different site on the same domain where feature is not needed. 409 // We go to a different site on the same domain where feature is not needed.
406 PasswordForm form2(form); 410 PasswordForm form2(form);
407 form2.origin = GURL("https://some.other.google.com/"); 411 form2.origin = GURL("https://some.other.google.com/");
408 form2.action = GURL("https://some.other.google.com/login"); 412 form2.action = GURL("https://some.other.google.com/login");
409 form2.signon_realm = "https://some.other.google.com/"; 413 form2.signon_realm = "https://some.other.google.com/";
410 414
411 // Match against the other site. Should not match since feature should not be 415 // Match against the other site. Should not match since feature should not be
412 // enabled for this domain. 416 // enabled for this domain.
413 EXPECT_TRUE(db_.GetLogins(form2, &result)); 417 EXPECT_TRUE(db().GetLogins(form2, &result));
414 EXPECT_EQ(0U, result.size()); 418 EXPECT_EQ(0U, result.size());
415 } 419 }
416 420
417 // This test fails if the implementation of GetLogins uses GetCachedStatement 421 // This test fails if the implementation of GetLogins uses GetCachedStatement
418 // instead of GetUniqueStatement, since REGEXP is in use. See 422 // instead of GetUniqueStatement, since REGEXP is in use. See
419 // http://crbug.com/248608. 423 // http://crbug.com/248608.
420 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingDifferentSites) { 424 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingDifferentSites) {
421 std::vector<PasswordForm*> result; 425 std::vector<PasswordForm*> result;
422 426
423 // Verify the database is empty. 427 // Verify the database is empty.
424 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 428 EXPECT_TRUE(db().GetAutofillableLogins(&result));
425 EXPECT_EQ(0U, result.size()); 429 EXPECT_EQ(0U, result.size());
426 430
427 // Example password form. 431 // Example password form.
428 PasswordForm form; 432 PasswordForm form;
429 form.origin = GURL("https://foo.com/"); 433 form.origin = GURL("https://foo.com/");
430 form.action = GURL("https://foo.com/login"); 434 form.action = GURL("https://foo.com/login");
431 form.username_element = ASCIIToUTF16("username"); 435 form.username_element = ASCIIToUTF16("username");
432 form.username_value = ASCIIToUTF16("test@gmail.com"); 436 form.username_value = ASCIIToUTF16("test@gmail.com");
433 form.password_element = ASCIIToUTF16("password"); 437 form.password_element = ASCIIToUTF16("password");
434 form.password_value = ASCIIToUTF16("test"); 438 form.password_value = ASCIIToUTF16("test");
435 form.submit_element = ASCIIToUTF16(""); 439 form.submit_element = ASCIIToUTF16("");
436 form.signon_realm = "https://foo.com/"; 440 form.signon_realm = "https://foo.com/";
437 form.ssl_valid = true; 441 form.ssl_valid = true;
438 form.preferred = false; 442 form.preferred = false;
439 form.scheme = PasswordForm::SCHEME_HTML; 443 form.scheme = PasswordForm::SCHEME_HTML;
440 444
441 // Add it and make sure it is there. 445 // Add it and make sure it is there.
442 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 446 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
443 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 447 EXPECT_TRUE(db().GetAutofillableLogins(&result));
444 EXPECT_EQ(1U, result.size()); 448 EXPECT_EQ(1U, result.size());
445 delete result[0]; 449 delete result[0];
446 result.clear(); 450 result.clear();
447 451
448 // Match against an exact copy. 452 // Match against an exact copy.
449 EXPECT_TRUE(db_.GetLogins(form, &result)); 453 EXPECT_TRUE(db().GetLogins(form, &result));
450 EXPECT_EQ(1U, result.size()); 454 EXPECT_EQ(1U, result.size());
451 delete result[0]; 455 delete result[0];
452 result.clear(); 456 result.clear();
453 457
454 // We go to the mobile site. 458 // We go to the mobile site.
455 PasswordForm form2(form); 459 PasswordForm form2(form);
456 form2.origin = GURL("https://mobile.foo.com/"); 460 form2.origin = GURL("https://mobile.foo.com/");
457 form2.action = GURL("https://mobile.foo.com/login"); 461 form2.action = GURL("https://mobile.foo.com/login");
458 form2.signon_realm = "https://mobile.foo.com/"; 462 form2.signon_realm = "https://mobile.foo.com/";
459 463
460 // Match against the mobile site. 464 // Match against the mobile site.
461 EXPECT_TRUE(db_.GetLogins(form2, &result)); 465 EXPECT_TRUE(db().GetLogins(form2, &result));
462 EXPECT_EQ(1U, result.size()); 466 EXPECT_EQ(1U, result.size());
463 EXPECT_EQ("https://mobile.foo.com/", result[0]->signon_realm); 467 EXPECT_EQ("https://mobile.foo.com/", result[0]->signon_realm);
464 EXPECT_EQ("https://foo.com/", result[0]->original_signon_realm); 468 EXPECT_EQ("https://foo.com/", result[0]->original_signon_realm);
465 delete result[0]; 469 delete result[0];
466 result.clear(); 470 result.clear();
467 471
468 // Add baz.com desktop site. 472 // Add baz.com desktop site.
469 form.origin = GURL("https://baz.com/login/"); 473 form.origin = GURL("https://baz.com/login/");
470 form.action = GURL("https://baz.com/login/"); 474 form.action = GURL("https://baz.com/login/");
471 form.username_element = ASCIIToUTF16("email"); 475 form.username_element = ASCIIToUTF16("email");
472 form.username_value = ASCIIToUTF16("test@gmail.com"); 476 form.username_value = ASCIIToUTF16("test@gmail.com");
473 form.password_element = ASCIIToUTF16("password"); 477 form.password_element = ASCIIToUTF16("password");
474 form.password_value = ASCIIToUTF16("test"); 478 form.password_value = ASCIIToUTF16("test");
475 form.submit_element = ASCIIToUTF16(""); 479 form.submit_element = ASCIIToUTF16("");
476 form.signon_realm = "https://baz.com/"; 480 form.signon_realm = "https://baz.com/";
477 form.ssl_valid = true; 481 form.ssl_valid = true;
478 form.preferred = false; 482 form.preferred = false;
479 form.scheme = PasswordForm::SCHEME_HTML; 483 form.scheme = PasswordForm::SCHEME_HTML;
480 484
481 // Add it and make sure it is there. 485 // Add it and make sure it is there.
482 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 486 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
483 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 487 EXPECT_TRUE(db().GetAutofillableLogins(&result));
484 EXPECT_EQ(2U, result.size()); 488 EXPECT_EQ(2U, result.size());
485 delete result[0]; 489 delete result[0];
486 delete result[1]; 490 delete result[1];
487 result.clear(); 491 result.clear();
488 492
489 // We go to the mobile site of baz.com. 493 // We go to the mobile site of baz.com.
490 PasswordForm form3(form); 494 PasswordForm form3(form);
491 form3.origin = GURL("https://m.baz.com/login/"); 495 form3.origin = GURL("https://m.baz.com/login/");
492 form3.action = GURL("https://m.baz.com/login/"); 496 form3.action = GURL("https://m.baz.com/login/");
493 form3.signon_realm = "https://m.baz.com/"; 497 form3.signon_realm = "https://m.baz.com/";
494 498
495 // Match against the mobile site of baz.com. 499 // Match against the mobile site of baz.com.
496 EXPECT_TRUE(db_.GetLogins(form3, &result)); 500 EXPECT_TRUE(db().GetLogins(form3, &result));
497 EXPECT_EQ(1U, result.size()); 501 EXPECT_EQ(1U, result.size());
498 EXPECT_EQ("https://m.baz.com/", result[0]->signon_realm); 502 EXPECT_EQ("https://m.baz.com/", result[0]->signon_realm);
499 EXPECT_EQ("https://baz.com/", result[0]->original_signon_realm); 503 EXPECT_EQ("https://baz.com/", result[0]->original_signon_realm);
500 delete result[0]; 504 delete result[0];
501 result.clear(); 505 result.clear();
502 } 506 }
503 507
504 PasswordForm GetFormWithNewSignonRealm(PasswordForm form, 508 PasswordForm GetFormWithNewSignonRealm(PasswordForm form,
505 std::string signon_realm) { 509 std::string signon_realm) {
506 PasswordForm form2(form); 510 PasswordForm form2(form);
507 form2.origin = GURL(signon_realm); 511 form2.origin = GURL(signon_realm);
508 form2.action = GURL(signon_realm); 512 form2.action = GURL(signon_realm);
509 form2.signon_realm = signon_realm; 513 form2.signon_realm = signon_realm;
510 return form2; 514 return form2;
511 } 515 }
512 516
513 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingRegexp) { 517 TEST_F(LoginDatabaseTest, TestPublicSuffixDomainMatchingRegexp) {
514 std::vector<PasswordForm*> result; 518 std::vector<PasswordForm*> result;
515 519
516 // Verify the database is empty. 520 // Verify the database is empty.
517 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 521 EXPECT_TRUE(db().GetAutofillableLogins(&result));
518 EXPECT_EQ(0U, result.size()); 522 EXPECT_EQ(0U, result.size());
519 523
520 // Example password form. 524 // Example password form.
521 PasswordForm form; 525 PasswordForm form;
522 form.origin = GURL("http://foo.com/"); 526 form.origin = GURL("http://foo.com/");
523 form.action = GURL("http://foo.com/login"); 527 form.action = GURL("http://foo.com/login");
524 form.username_element = ASCIIToUTF16("username"); 528 form.username_element = ASCIIToUTF16("username");
525 form.username_value = ASCIIToUTF16("test@gmail.com"); 529 form.username_value = ASCIIToUTF16("test@gmail.com");
526 form.password_element = ASCIIToUTF16("password"); 530 form.password_element = ASCIIToUTF16("password");
527 form.password_value = ASCIIToUTF16("test"); 531 form.password_value = ASCIIToUTF16("test");
528 form.submit_element = ASCIIToUTF16(""); 532 form.submit_element = ASCIIToUTF16("");
529 form.signon_realm = "http://foo.com/"; 533 form.signon_realm = "http://foo.com/";
530 form.ssl_valid = false; 534 form.ssl_valid = false;
531 form.preferred = false; 535 form.preferred = false;
532 form.scheme = PasswordForm::SCHEME_HTML; 536 form.scheme = PasswordForm::SCHEME_HTML;
533 537
534 // Add it and make sure it is there. 538 // Add it and make sure it is there.
535 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 539 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
536 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 540 EXPECT_TRUE(db().GetAutofillableLogins(&result));
537 EXPECT_EQ(1U, result.size()); 541 EXPECT_EQ(1U, result.size());
538 delete result[0]; 542 delete result[0];
539 result.clear(); 543 result.clear();
540 544
541 // Example password form that has - in the domain name. 545 // Example password form that has - in the domain name.
542 PasswordForm form_dash = 546 PasswordForm form_dash =
543 GetFormWithNewSignonRealm(form, "http://www.foo-bar.com/"); 547 GetFormWithNewSignonRealm(form, "http://www.foo-bar.com/");
544 548
545 // Add it and make sure it is there. 549 // Add it and make sure it is there.
546 EXPECT_EQ(AddChangeForForm(form_dash), db_.AddLogin(form_dash)); 550 EXPECT_EQ(AddChangeForForm(form_dash), db().AddLogin(form_dash));
547 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 551 EXPECT_TRUE(db().GetAutofillableLogins(&result));
548 EXPECT_EQ(2U, result.size()); 552 EXPECT_EQ(2U, result.size());
549 delete result[0]; 553 delete result[0];
550 delete result[1]; 554 delete result[1];
551 result.clear(); 555 result.clear();
552 556
553 // Match against an exact copy. 557 // Match against an exact copy.
554 EXPECT_TRUE(db_.GetLogins(form, &result)); 558 EXPECT_TRUE(db().GetLogins(form, &result));
555 EXPECT_EQ(1U, result.size()); 559 EXPECT_EQ(1U, result.size());
556 delete result[0]; 560 delete result[0];
557 result.clear(); 561 result.clear();
558 562
559 // www.foo.com should match. 563 // www.foo.com should match.
560 PasswordForm form2 = GetFormWithNewSignonRealm(form, "http://www.foo.com/"); 564 PasswordForm form2 = GetFormWithNewSignonRealm(form, "http://www.foo.com/");
561 EXPECT_TRUE(db_.GetLogins(form2, &result)); 565 EXPECT_TRUE(db().GetLogins(form2, &result));
562 EXPECT_EQ(1U, result.size()); 566 EXPECT_EQ(1U, result.size());
563 delete result[0]; 567 delete result[0];
564 result.clear(); 568 result.clear();
565 569
566 // a.b.foo.com should match. 570 // a.b.foo.com should match.
567 form2 = GetFormWithNewSignonRealm(form, "http://a.b.foo.com/"); 571 form2 = GetFormWithNewSignonRealm(form, "http://a.b.foo.com/");
568 EXPECT_TRUE(db_.GetLogins(form2, &result)); 572 EXPECT_TRUE(db().GetLogins(form2, &result));
569 EXPECT_EQ(1U, result.size()); 573 EXPECT_EQ(1U, result.size());
570 delete result[0]; 574 delete result[0];
571 result.clear(); 575 result.clear();
572 576
573 // a-b.foo.com should match. 577 // a-b.foo.com should match.
574 form2 = GetFormWithNewSignonRealm(form, "http://a-b.foo.com/"); 578 form2 = GetFormWithNewSignonRealm(form, "http://a-b.foo.com/");
575 EXPECT_TRUE(db_.GetLogins(form2, &result)); 579 EXPECT_TRUE(db().GetLogins(form2, &result));
576 EXPECT_EQ(1U, result.size()); 580 EXPECT_EQ(1U, result.size());
577 delete result[0]; 581 delete result[0];
578 result.clear(); 582 result.clear();
579 583
580 // foo-bar.com should match. 584 // foo-bar.com should match.
581 form2 = GetFormWithNewSignonRealm(form, "http://foo-bar.com/"); 585 form2 = GetFormWithNewSignonRealm(form, "http://foo-bar.com/");
582 EXPECT_TRUE(db_.GetLogins(form2, &result)); 586 EXPECT_TRUE(db().GetLogins(form2, &result));
583 EXPECT_EQ(1U, result.size()); 587 EXPECT_EQ(1U, result.size());
584 delete result[0]; 588 delete result[0];
585 result.clear(); 589 result.clear();
586 590
587 // www.foo-bar.com should match. 591 // www.foo-bar.com should match.
588 form2 = GetFormWithNewSignonRealm(form, "http://www.foo-bar.com/"); 592 form2 = GetFormWithNewSignonRealm(form, "http://www.foo-bar.com/");
589 EXPECT_TRUE(db_.GetLogins(form2, &result)); 593 EXPECT_TRUE(db().GetLogins(form2, &result));
590 EXPECT_EQ(1U, result.size()); 594 EXPECT_EQ(1U, result.size());
591 delete result[0]; 595 delete result[0];
592 result.clear(); 596 result.clear();
593 597
594 // a.b.foo-bar.com should match. 598 // a.b.foo-bar.com should match.
595 form2 = GetFormWithNewSignonRealm(form, "http://a.b.foo-bar.com/"); 599 form2 = GetFormWithNewSignonRealm(form, "http://a.b.foo-bar.com/");
596 EXPECT_TRUE(db_.GetLogins(form2, &result)); 600 EXPECT_TRUE(db().GetLogins(form2, &result));
597 EXPECT_EQ(1U, result.size()); 601 EXPECT_EQ(1U, result.size());
598 delete result[0]; 602 delete result[0];
599 result.clear(); 603 result.clear();
600 604
601 // a-b.foo-bar.com should match. 605 // a-b.foo-bar.com should match.
602 form2 = GetFormWithNewSignonRealm(form, "http://a-b.foo-bar.com/"); 606 form2 = GetFormWithNewSignonRealm(form, "http://a-b.foo-bar.com/");
603 EXPECT_TRUE(db_.GetLogins(form2, &result)); 607 EXPECT_TRUE(db().GetLogins(form2, &result));
604 EXPECT_EQ(1U, result.size()); 608 EXPECT_EQ(1U, result.size());
605 delete result[0]; 609 delete result[0];
606 result.clear(); 610 result.clear();
607 611
608 // foo.com with port 1337 should not match. 612 // foo.com with port 1337 should not match.
609 form2 = GetFormWithNewSignonRealm(form, "http://foo.com:1337/"); 613 form2 = GetFormWithNewSignonRealm(form, "http://foo.com:1337/");
610 EXPECT_TRUE(db_.GetLogins(form2, &result)); 614 EXPECT_TRUE(db().GetLogins(form2, &result));
611 EXPECT_EQ(0U, result.size()); 615 EXPECT_EQ(0U, result.size());
612 616
613 // http://foo.com should not match since the scheme is wrong. 617 // http://foo.com should not match since the scheme is wrong.
614 form2 = GetFormWithNewSignonRealm(form, "https://foo.com/"); 618 form2 = GetFormWithNewSignonRealm(form, "https://foo.com/");
615 EXPECT_TRUE(db_.GetLogins(form2, &result)); 619 EXPECT_TRUE(db().GetLogins(form2, &result));
616 EXPECT_EQ(0U, result.size()); 620 EXPECT_EQ(0U, result.size());
617 621
618 // notfoo.com should not match. 622 // notfoo.com should not match.
619 form2 = GetFormWithNewSignonRealm(form, "http://notfoo.com/"); 623 form2 = GetFormWithNewSignonRealm(form, "http://notfoo.com/");
620 EXPECT_TRUE(db_.GetLogins(form2, &result)); 624 EXPECT_TRUE(db().GetLogins(form2, &result));
621 EXPECT_EQ(0U, result.size()); 625 EXPECT_EQ(0U, result.size());
622 626
623 // baz.com should not match. 627 // baz.com should not match.
624 form2 = GetFormWithNewSignonRealm(form, "http://baz.com/"); 628 form2 = GetFormWithNewSignonRealm(form, "http://baz.com/");
625 EXPECT_TRUE(db_.GetLogins(form2, &result)); 629 EXPECT_TRUE(db().GetLogins(form2, &result));
626 EXPECT_EQ(0U, result.size()); 630 EXPECT_EQ(0U, result.size());
627 631
628 // foo-baz.com should not match. 632 // foo-baz.com should not match.
629 form2 = GetFormWithNewSignonRealm(form, "http://foo-baz.com/"); 633 form2 = GetFormWithNewSignonRealm(form, "http://foo-baz.com/");
630 EXPECT_TRUE(db_.GetLogins(form2, &result)); 634 EXPECT_TRUE(db().GetLogins(form2, &result));
631 EXPECT_EQ(0U, result.size()); 635 EXPECT_EQ(0U, result.size());
632 } 636 }
633 637
634 static bool AddTimestampedLogin(LoginDatabase* db, 638 static bool AddTimestampedLogin(LoginDatabase* db,
635 std::string url, 639 std::string url,
636 const std::string& unique_string, 640 const std::string& unique_string,
637 const base::Time& time, 641 const base::Time& time,
638 bool date_is_creation) { 642 bool date_is_creation) {
639 // Example password form. 643 // Example password form.
640 PasswordForm form; 644 PasswordForm form;
(...skipping 19 matching lines...) Expand all
660 for (size_t i = 0; i < results->size(); ++i) { 664 for (size_t i = 0; i < results->size(); ++i) {
661 delete (*results)[i]; 665 delete (*results)[i];
662 } 666 }
663 results->clear(); 667 results->clear();
664 } 668 }
665 669
666 TEST_F(LoginDatabaseTest, ClearPrivateData_SavedPasswords) { 670 TEST_F(LoginDatabaseTest, ClearPrivateData_SavedPasswords) {
667 std::vector<PasswordForm*> result; 671 std::vector<PasswordForm*> result;
668 672
669 // Verify the database is empty. 673 // Verify the database is empty.
670 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 674 EXPECT_TRUE(db().GetAutofillableLogins(&result));
671 EXPECT_EQ(0U, result.size()); 675 EXPECT_EQ(0U, result.size());
672 676
673 base::Time now = base::Time::Now(); 677 base::Time now = base::Time::Now();
674 base::TimeDelta one_day = base::TimeDelta::FromDays(1); 678 base::TimeDelta one_day = base::TimeDelta::FromDays(1);
675 679
676 // Create one with a 0 time. 680 // Create one with a 0 time.
677 EXPECT_TRUE( 681 EXPECT_TRUE(
678 AddTimestampedLogin(&db_, "http://1.com", "foo1", base::Time(), true)); 682 AddTimestampedLogin(&db(), "http://1.com", "foo1", base::Time(), true));
679 // Create one for now and +/- 1 day. 683 // Create one for now and +/- 1 day.
680 EXPECT_TRUE( 684 EXPECT_TRUE(
681 AddTimestampedLogin(&db_, "http://2.com", "foo2", now - one_day, true)); 685 AddTimestampedLogin(&db(), "http://2.com", "foo2", now - one_day, true));
682 EXPECT_TRUE(AddTimestampedLogin(&db_, "http://3.com", "foo3", now, true)); 686 EXPECT_TRUE(AddTimestampedLogin(&db(), "http://3.com", "foo3", now, true));
683 EXPECT_TRUE( 687 EXPECT_TRUE(
684 AddTimestampedLogin(&db_, "http://4.com", "foo4", now + one_day, true)); 688 AddTimestampedLogin(&db(), "http://4.com", "foo4", now + one_day, true));
685 689
686 // Verify inserts worked. 690 // Verify inserts worked.
687 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 691 EXPECT_TRUE(db().GetAutofillableLogins(&result));
688 EXPECT_EQ(4U, result.size()); 692 EXPECT_EQ(4U, result.size());
689 ClearResults(&result); 693 ClearResults(&result);
690 694
691 // Get everything from today's date and on. 695 // Get everything from today's date and on.
692 EXPECT_TRUE(db_.GetLoginsCreatedBetween(now, base::Time(), &result)); 696 EXPECT_TRUE(db().GetLoginsCreatedBetween(now, base::Time(), &result));
693 EXPECT_EQ(2U, result.size()); 697 EXPECT_EQ(2U, result.size());
694 ClearResults(&result); 698 ClearResults(&result);
695 699
696 // Delete everything from today's date and on. 700 // Delete everything from today's date and on.
697 db_.RemoveLoginsCreatedBetween(now, base::Time()); 701 db().RemoveLoginsCreatedBetween(now, base::Time());
698 702
699 // Should have deleted half of what we inserted. 703 // Should have deleted half of what we inserted.
700 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 704 EXPECT_TRUE(db().GetAutofillableLogins(&result));
701 EXPECT_EQ(2U, result.size()); 705 EXPECT_EQ(2U, result.size());
702 ClearResults(&result); 706 ClearResults(&result);
703 707
704 // Delete with 0 date (should delete all). 708 // Delete with 0 date (should delete all).
705 db_.RemoveLoginsCreatedBetween(base::Time(), base::Time()); 709 db().RemoveLoginsCreatedBetween(base::Time(), base::Time());
706 710
707 // Verify nothing is left. 711 // Verify nothing is left.
708 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 712 EXPECT_TRUE(db().GetAutofillableLogins(&result));
709 EXPECT_EQ(0U, result.size()); 713 EXPECT_EQ(0U, result.size());
710 } 714 }
711 715
712 TEST_F(LoginDatabaseTest, RemoveLoginsSyncedBetween) { 716 TEST_F(LoginDatabaseTest, RemoveLoginsSyncedBetween) {
713 ScopedVector<autofill::PasswordForm> result; 717 ScopedVector<autofill::PasswordForm> result;
714 718
715 base::Time now = base::Time::Now(); 719 base::Time now = base::Time::Now();
716 base::TimeDelta one_day = base::TimeDelta::FromDays(1); 720 base::TimeDelta one_day = base::TimeDelta::FromDays(1);
717 721
718 // Create one with a 0 time. 722 // Create one with a 0 time.
719 EXPECT_TRUE( 723 EXPECT_TRUE(
720 AddTimestampedLogin(&db_, "http://1.com", "foo1", base::Time(), false)); 724 AddTimestampedLogin(&db(), "http://1.com", "foo1", base::Time(), false));
721 // Create one for now and +/- 1 day. 725 // Create one for now and +/- 1 day.
722 EXPECT_TRUE( 726 EXPECT_TRUE(
723 AddTimestampedLogin(&db_, "http://2.com", "foo2", now - one_day, false)); 727 AddTimestampedLogin(&db(), "http://2.com", "foo2", now - one_day, false));
724 EXPECT_TRUE(AddTimestampedLogin(&db_, "http://3.com", "foo3", now, false)); 728 EXPECT_TRUE(AddTimestampedLogin(&db(), "http://3.com", "foo3", now, false));
725 EXPECT_TRUE( 729 EXPECT_TRUE(
726 AddTimestampedLogin(&db_, "http://4.com", "foo4", now + one_day, false)); 730 AddTimestampedLogin(&db(), "http://4.com", "foo4", now + one_day, false));
727 731
728 // Verify inserts worked. 732 // Verify inserts worked.
729 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 733 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
730 EXPECT_EQ(4U, result.size()); 734 EXPECT_EQ(4U, result.size());
731 result.clear(); 735 result.clear();
732 736
733 // Get everything from today's date and on. 737 // Get everything from today's date and on.
734 EXPECT_TRUE(db_.GetLoginsSyncedBetween(now, base::Time(), &result.get())); 738 EXPECT_TRUE(db().GetLoginsSyncedBetween(now, base::Time(), &result.get()));
735 ASSERT_EQ(2U, result.size()); 739 ASSERT_EQ(2U, result.size());
736 EXPECT_EQ("http://3.com", result[0]->signon_realm); 740 EXPECT_EQ("http://3.com", result[0]->signon_realm);
737 EXPECT_EQ("http://4.com", result[1]->signon_realm); 741 EXPECT_EQ("http://4.com", result[1]->signon_realm);
738 result.clear(); 742 result.clear();
739 743
740 // Delete everything from today's date and on. 744 // Delete everything from today's date and on.
741 db_.RemoveLoginsSyncedBetween(now, base::Time()); 745 db().RemoveLoginsSyncedBetween(now, base::Time());
742 746
743 // Should have deleted half of what we inserted. 747 // Should have deleted half of what we inserted.
744 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 748 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
745 ASSERT_EQ(2U, result.size()); 749 ASSERT_EQ(2U, result.size());
746 EXPECT_EQ("http://1.com", result[0]->signon_realm); 750 EXPECT_EQ("http://1.com", result[0]->signon_realm);
747 EXPECT_EQ("http://2.com", result[1]->signon_realm); 751 EXPECT_EQ("http://2.com", result[1]->signon_realm);
748 result.clear(); 752 result.clear();
749 753
750 // Delete with 0 date (should delete all). 754 // Delete with 0 date (should delete all).
751 db_.RemoveLoginsSyncedBetween(base::Time(), now); 755 db().RemoveLoginsSyncedBetween(base::Time(), now);
752 756
753 // Verify nothing is left. 757 // Verify nothing is left.
754 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 758 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
755 EXPECT_EQ(0U, result.size()); 759 EXPECT_EQ(0U, result.size());
756 } 760 }
757 761
758 TEST_F(LoginDatabaseTest, BlacklistedLogins) { 762 TEST_F(LoginDatabaseTest, BlacklistedLogins) {
759 std::vector<PasswordForm*> result; 763 std::vector<PasswordForm*> result;
760 764
761 // Verify the database is empty. 765 // Verify the database is empty.
762 EXPECT_TRUE(db_.GetBlacklistLogins(&result)); 766 EXPECT_TRUE(db().GetBlacklistLogins(&result));
763 ASSERT_EQ(0U, result.size()); 767 ASSERT_EQ(0U, result.size());
764 768
765 // Save a form as blacklisted. 769 // Save a form as blacklisted.
766 PasswordForm form; 770 PasswordForm form;
767 form.origin = GURL("http://accounts.google.com/LoginAuth"); 771 form.origin = GURL("http://accounts.google.com/LoginAuth");
768 form.action = GURL("http://accounts.google.com/Login"); 772 form.action = GURL("http://accounts.google.com/Login");
769 form.username_element = ASCIIToUTF16("Email"); 773 form.username_element = ASCIIToUTF16("Email");
770 form.password_element = ASCIIToUTF16("Passwd"); 774 form.password_element = ASCIIToUTF16("Passwd");
771 form.submit_element = ASCIIToUTF16("signIn"); 775 form.submit_element = ASCIIToUTF16("signIn");
772 form.signon_realm = "http://www.google.com/"; 776 form.signon_realm = "http://www.google.com/";
773 form.ssl_valid = false; 777 form.ssl_valid = false;
774 form.preferred = true; 778 form.preferred = true;
775 form.blacklisted_by_user = true; 779 form.blacklisted_by_user = true;
776 form.scheme = PasswordForm::SCHEME_HTML; 780 form.scheme = PasswordForm::SCHEME_HTML;
777 form.date_synced = base::Time::Now(); 781 form.date_synced = base::Time::Now();
778 form.display_name = ASCIIToUTF16("Mr. Smith"); 782 form.display_name = ASCIIToUTF16("Mr. Smith");
779 form.avatar_url = GURL("https://accounts.google.com/Avatar"); 783 form.avatar_url = GURL("https://accounts.google.com/Avatar");
780 form.federation_url = GURL("https://accounts.google.com/federation"); 784 form.federation_url = GURL("https://accounts.google.com/federation");
781 form.is_zero_click = true; 785 form.is_zero_click = true;
782 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 786 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
783 787
784 // Get all non-blacklisted logins (should be none). 788 // Get all non-blacklisted logins (should be none).
785 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 789 EXPECT_TRUE(db().GetAutofillableLogins(&result));
786 ASSERT_EQ(0U, result.size()); 790 ASSERT_EQ(0U, result.size());
787 791
788 // GetLogins should give the blacklisted result. 792 // GetLogins should give the blacklisted result.
789 EXPECT_TRUE(db_.GetLogins(form, &result)); 793 EXPECT_TRUE(db().GetLogins(form, &result));
790 ASSERT_EQ(1U, result.size()); 794 ASSERT_EQ(1U, result.size());
791 FormsAreEqual(form, *result[0]); 795 FormsAreEqual(form, *result[0]);
792 ClearResults(&result); 796 ClearResults(&result);
793 797
794 // So should GetAllBlacklistedLogins. 798 // So should GetAllBlacklistedLogins.
795 EXPECT_TRUE(db_.GetBlacklistLogins(&result)); 799 EXPECT_TRUE(db().GetBlacklistLogins(&result));
796 ASSERT_EQ(1U, result.size()); 800 ASSERT_EQ(1U, result.size());
797 FormsAreEqual(form, *result[0]); 801 FormsAreEqual(form, *result[0]);
798 ClearResults(&result); 802 ClearResults(&result);
799 } 803 }
800 804
801 TEST_F(LoginDatabaseTest, VectorSerialization) { 805 TEST_F(LoginDatabaseTest, VectorSerialization) {
802 // Empty vector. 806 // Empty vector.
803 std::vector<base::string16> vec; 807 std::vector<base::string16> vec;
804 Pickle temp = SerializeVector(vec); 808 Pickle temp = SerializeVector(vec);
805 std::vector<base::string16> output = DeserializeVector(temp); 809 std::vector<base::string16> output = DeserializeVector(temp);
806 EXPECT_THAT(output, Eq(vec)); 810 EXPECT_THAT(output, Eq(vec));
807 811
808 // Normal data. 812 // Normal data.
809 vec.push_back(ASCIIToUTF16("first")); 813 vec.push_back(ASCIIToUTF16("first"));
810 vec.push_back(ASCIIToUTF16("second")); 814 vec.push_back(ASCIIToUTF16("second"));
811 vec.push_back(ASCIIToUTF16("third")); 815 vec.push_back(ASCIIToUTF16("third"));
812 816
813 temp = SerializeVector(vec); 817 temp = SerializeVector(vec);
814 output = DeserializeVector(temp); 818 output = DeserializeVector(temp);
815 EXPECT_THAT(output, Eq(vec)); 819 EXPECT_THAT(output, Eq(vec));
816 } 820 }
817 821
818 TEST_F(LoginDatabaseTest, UpdateIncompleteCredentials) { 822 TEST_F(LoginDatabaseTest, UpdateIncompleteCredentials) {
819 std::vector<autofill::PasswordForm*> result; 823 std::vector<autofill::PasswordForm*> result;
820 // Verify the database is empty. 824 // Verify the database is empty.
821 EXPECT_TRUE(db_.GetAutofillableLogins(&result)); 825 EXPECT_TRUE(db().GetAutofillableLogins(&result));
822 ASSERT_EQ(0U, result.size()); 826 ASSERT_EQ(0U, result.size());
823 827
824 // Save an incomplete form. Note that it only has a few fields set, ex. it's 828 // Save an incomplete form. Note that it only has a few fields set, ex. it's
825 // missing 'action', 'username_element' and 'password_element'. Such forms 829 // missing 'action', 'username_element' and 'password_element'. Such forms
826 // are sometimes inserted during import from other browsers (which may not 830 // are sometimes inserted during import from other browsers (which may not
827 // store this info). 831 // store this info).
828 PasswordForm incomplete_form; 832 PasswordForm incomplete_form;
829 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); 833 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth");
830 incomplete_form.signon_realm = "http://accounts.google.com/"; 834 incomplete_form.signon_realm = "http://accounts.google.com/";
831 incomplete_form.username_value = ASCIIToUTF16("my_username"); 835 incomplete_form.username_value = ASCIIToUTF16("my_username");
832 incomplete_form.password_value = ASCIIToUTF16("my_password"); 836 incomplete_form.password_value = ASCIIToUTF16("my_password");
833 incomplete_form.ssl_valid = false; 837 incomplete_form.ssl_valid = false;
834 incomplete_form.preferred = true; 838 incomplete_form.preferred = true;
835 incomplete_form.blacklisted_by_user = false; 839 incomplete_form.blacklisted_by_user = false;
836 incomplete_form.scheme = PasswordForm::SCHEME_HTML; 840 incomplete_form.scheme = PasswordForm::SCHEME_HTML;
837 EXPECT_EQ(AddChangeForForm(incomplete_form), db_.AddLogin(incomplete_form)); 841 EXPECT_EQ(AddChangeForForm(incomplete_form), db().AddLogin(incomplete_form));
838 842
839 // A form on some website. It should trigger a match with the stored one. 843 // A form on some website. It should trigger a match with the stored one.
840 PasswordForm encountered_form; 844 PasswordForm encountered_form;
841 encountered_form.origin = GURL("http://accounts.google.com/LoginAuth"); 845 encountered_form.origin = GURL("http://accounts.google.com/LoginAuth");
842 encountered_form.signon_realm = "http://accounts.google.com/"; 846 encountered_form.signon_realm = "http://accounts.google.com/";
843 encountered_form.action = GURL("http://accounts.google.com/Login"); 847 encountered_form.action = GURL("http://accounts.google.com/Login");
844 encountered_form.username_element = ASCIIToUTF16("Email"); 848 encountered_form.username_element = ASCIIToUTF16("Email");
845 encountered_form.password_element = ASCIIToUTF16("Passwd"); 849 encountered_form.password_element = ASCIIToUTF16("Passwd");
846 encountered_form.submit_element = ASCIIToUTF16("signIn"); 850 encountered_form.submit_element = ASCIIToUTF16("signIn");
847 851
848 // Get matches for encountered_form. 852 // Get matches for encountered_form.
849 EXPECT_TRUE(db_.GetLogins(encountered_form, &result)); 853 EXPECT_TRUE(db().GetLogins(encountered_form, &result));
850 ASSERT_EQ(1U, result.size()); 854 ASSERT_EQ(1U, result.size());
851 EXPECT_EQ(incomplete_form.origin, result[0]->origin); 855 EXPECT_EQ(incomplete_form.origin, result[0]->origin);
852 EXPECT_EQ(incomplete_form.signon_realm, result[0]->signon_realm); 856 EXPECT_EQ(incomplete_form.signon_realm, result[0]->signon_realm);
853 EXPECT_EQ(incomplete_form.username_value, result[0]->username_value); 857 EXPECT_EQ(incomplete_form.username_value, result[0]->username_value);
854 #if defined(OS_MACOSX) && !defined(OS_IOS) 858 #if defined(OS_MACOSX) && !defined(OS_IOS)
855 // On Mac, passwords are not stored in login database, instead they're in 859 // On Mac, passwords are not stored in login database, instead they're in
856 // the keychain. 860 // the keychain.
857 EXPECT_TRUE(result[0]->password_value.empty()); 861 EXPECT_TRUE(result[0]->password_value.empty());
858 #else 862 #else
859 EXPECT_EQ(incomplete_form.password_value, result[0]->password_value); 863 EXPECT_EQ(incomplete_form.password_value, result[0]->password_value);
(...skipping 11 matching lines...) Expand all
871 ClearResults(&result); 875 ClearResults(&result);
872 876
873 // Let's say this login form worked. Now update the stored credentials with 877 // Let's say this login form worked. Now update the stored credentials with
874 // 'action', 'username_element', 'password_element' and 'submit_element' from 878 // 'action', 'username_element', 'password_element' and 'submit_element' from
875 // the encountered form. 879 // the encountered form.
876 PasswordForm completed_form(incomplete_form); 880 PasswordForm completed_form(incomplete_form);
877 completed_form.action = encountered_form.action; 881 completed_form.action = encountered_form.action;
878 completed_form.username_element = encountered_form.username_element; 882 completed_form.username_element = encountered_form.username_element;
879 completed_form.password_element = encountered_form.password_element; 883 completed_form.password_element = encountered_form.password_element;
880 completed_form.submit_element = encountered_form.submit_element; 884 completed_form.submit_element = encountered_form.submit_element;
881 EXPECT_EQ(AddChangeForForm(completed_form), db_.AddLogin(completed_form)); 885 EXPECT_EQ(AddChangeForForm(completed_form), db().AddLogin(completed_form));
882 EXPECT_TRUE(db_.RemoveLogin(incomplete_form)); 886 EXPECT_TRUE(db().RemoveLogin(incomplete_form));
883 887
884 // Get matches for encountered_form again. 888 // Get matches for encountered_form again.
885 EXPECT_TRUE(db_.GetLogins(encountered_form, &result)); 889 EXPECT_TRUE(db().GetLogins(encountered_form, &result));
886 ASSERT_EQ(1U, result.size()); 890 ASSERT_EQ(1U, result.size());
887 891
888 // This time we should have all the info available. 892 // This time we should have all the info available.
889 PasswordForm expected_form(completed_form); 893 PasswordForm expected_form(completed_form);
890 #if defined(OS_MACOSX) && !defined(OS_IOS) 894 #if defined(OS_MACOSX) && !defined(OS_IOS)
891 expected_form.password_value.clear(); 895 expected_form.password_value.clear();
892 #endif // OS_MACOSX && !OS_IOS 896 #endif // OS_MACOSX && !OS_IOS
893 EXPECT_EQ(expected_form, *result[0]); 897 EXPECT_EQ(expected_form, *result[0]);
894 ClearResults(&result); 898 ClearResults(&result);
895 } 899 }
896 900
897 TEST_F(LoginDatabaseTest, UpdateOverlappingCredentials) { 901 TEST_F(LoginDatabaseTest, UpdateOverlappingCredentials) {
898 // Save an incomplete form. Note that it only has a few fields set, ex. it's 902 // Save an incomplete form. Note that it only has a few fields set, ex. it's
899 // missing 'action', 'username_element' and 'password_element'. Such forms 903 // missing 'action', 'username_element' and 'password_element'. Such forms
900 // are sometimes inserted during import from other browsers (which may not 904 // are sometimes inserted during import from other browsers (which may not
901 // store this info). 905 // store this info).
902 PasswordForm incomplete_form; 906 PasswordForm incomplete_form;
903 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth"); 907 incomplete_form.origin = GURL("http://accounts.google.com/LoginAuth");
904 incomplete_form.signon_realm = "http://accounts.google.com/"; 908 incomplete_form.signon_realm = "http://accounts.google.com/";
905 incomplete_form.username_value = ASCIIToUTF16("my_username"); 909 incomplete_form.username_value = ASCIIToUTF16("my_username");
906 incomplete_form.password_value = ASCIIToUTF16("my_password"); 910 incomplete_form.password_value = ASCIIToUTF16("my_password");
907 incomplete_form.ssl_valid = false; 911 incomplete_form.ssl_valid = false;
908 incomplete_form.preferred = true; 912 incomplete_form.preferred = true;
909 incomplete_form.blacklisted_by_user = false; 913 incomplete_form.blacklisted_by_user = false;
910 incomplete_form.scheme = PasswordForm::SCHEME_HTML; 914 incomplete_form.scheme = PasswordForm::SCHEME_HTML;
911 EXPECT_EQ(AddChangeForForm(incomplete_form), db_.AddLogin(incomplete_form)); 915 EXPECT_EQ(AddChangeForForm(incomplete_form), db().AddLogin(incomplete_form));
912 916
913 // Save a complete version of the previous form. Both forms could exist if 917 // Save a complete version of the previous form. Both forms could exist if
914 // the user created the complete version before importing the incomplete 918 // the user created the complete version before importing the incomplete
915 // version from a different browser. 919 // version from a different browser.
916 PasswordForm complete_form = incomplete_form; 920 PasswordForm complete_form = incomplete_form;
917 complete_form.action = GURL("http://accounts.google.com/Login"); 921 complete_form.action = GURL("http://accounts.google.com/Login");
918 complete_form.username_element = ASCIIToUTF16("username_element"); 922 complete_form.username_element = ASCIIToUTF16("username_element");
919 complete_form.password_element = ASCIIToUTF16("password_element"); 923 complete_form.password_element = ASCIIToUTF16("password_element");
920 complete_form.submit_element = ASCIIToUTF16("submit"); 924 complete_form.submit_element = ASCIIToUTF16("submit");
921 925
922 // An update fails because the primary key for |complete_form| is different. 926 // An update fails because the primary key for |complete_form| is different.
923 EXPECT_EQ(PasswordStoreChangeList(), db_.UpdateLogin(complete_form)); 927 EXPECT_EQ(PasswordStoreChangeList(), db().UpdateLogin(complete_form));
924 EXPECT_EQ(AddChangeForForm(complete_form), db_.AddLogin(complete_form)); 928 EXPECT_EQ(AddChangeForForm(complete_form), db().AddLogin(complete_form));
925 929
926 // Make sure both passwords exist. 930 // Make sure both passwords exist.
927 ScopedVector<autofill::PasswordForm> result; 931 ScopedVector<autofill::PasswordForm> result;
928 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 932 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
929 ASSERT_EQ(2U, result.size()); 933 ASSERT_EQ(2U, result.size());
930 result.clear(); 934 result.clear();
931 935
932 // Simulate the user changing their password. 936 // Simulate the user changing their password.
933 complete_form.password_value = ASCIIToUTF16("new_password"); 937 complete_form.password_value = ASCIIToUTF16("new_password");
934 complete_form.date_synced = base::Time::Now(); 938 complete_form.date_synced = base::Time::Now();
935 EXPECT_EQ(UpdateChangeForForm(complete_form), db_.UpdateLogin(complete_form)); 939 EXPECT_EQ(UpdateChangeForForm(complete_form),
940 db().UpdateLogin(complete_form));
936 941
937 // Both still exist now. 942 // Both still exist now.
938 EXPECT_TRUE(db_.GetAutofillableLogins(&result.get())); 943 EXPECT_TRUE(db().GetAutofillableLogins(&result.get()));
939 ASSERT_EQ(2U, result.size()); 944 ASSERT_EQ(2U, result.size());
940 945
941 #if defined(OS_MACOSX) && !defined(OS_IOS) 946 #if defined(OS_MACOSX) && !defined(OS_IOS)
942 // On Mac, passwords are not stored in login database, instead they're in 947 // On Mac, passwords are not stored in login database, instead they're in
943 // the keychain. 948 // the keychain.
944 complete_form.password_value.clear(); 949 complete_form.password_value.clear();
945 incomplete_form.password_value.clear(); 950 incomplete_form.password_value.clear();
946 #endif // OS_MACOSX && !OS_IOS 951 #endif // OS_MACOSX && !OS_IOS
947 if (result[0]->username_element.empty()) 952 if (result[0]->username_element.empty())
948 std::swap(result[0], result[1]); 953 std::swap(result[0], result[1]);
949 EXPECT_EQ(complete_form, *result[0]); 954 EXPECT_EQ(complete_form, *result[0]);
950 EXPECT_EQ(incomplete_form, *result[1]); 955 EXPECT_EQ(incomplete_form, *result[1]);
951 } 956 }
952 957
953 TEST_F(LoginDatabaseTest, DoubleAdd) { 958 TEST_F(LoginDatabaseTest, DoubleAdd) {
954 PasswordForm form; 959 PasswordForm form;
955 form.origin = GURL("http://accounts.google.com/LoginAuth"); 960 form.origin = GURL("http://accounts.google.com/LoginAuth");
956 form.signon_realm = "http://accounts.google.com/"; 961 form.signon_realm = "http://accounts.google.com/";
957 form.username_value = ASCIIToUTF16("my_username"); 962 form.username_value = ASCIIToUTF16("my_username");
958 form.password_value = ASCIIToUTF16("my_password"); 963 form.password_value = ASCIIToUTF16("my_password");
959 form.ssl_valid = false; 964 form.ssl_valid = false;
960 form.preferred = true; 965 form.preferred = true;
961 form.blacklisted_by_user = false; 966 form.blacklisted_by_user = false;
962 form.scheme = PasswordForm::SCHEME_HTML; 967 form.scheme = PasswordForm::SCHEME_HTML;
963 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 968 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
964 969
965 // Add almost the same form again. 970 // Add almost the same form again.
966 form.times_used++; 971 form.times_used++;
967 PasswordStoreChangeList list; 972 PasswordStoreChangeList list;
968 list.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form)); 973 list.push_back(PasswordStoreChange(PasswordStoreChange::REMOVE, form));
969 list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form)); 974 list.push_back(PasswordStoreChange(PasswordStoreChange::ADD, form));
970 EXPECT_EQ(list, db_.AddLogin(form)); 975 EXPECT_EQ(list, db().AddLogin(form));
971 } 976 }
972 977
973 TEST_F(LoginDatabaseTest, AddWrongForm) { 978 TEST_F(LoginDatabaseTest, AddWrongForm) {
974 PasswordForm form; 979 PasswordForm form;
975 // |origin| shouldn't be empty. 980 // |origin| shouldn't be empty.
976 form.origin = GURL(); 981 form.origin = GURL();
977 form.signon_realm = "http://accounts.google.com/"; 982 form.signon_realm = "http://accounts.google.com/";
978 form.username_value = ASCIIToUTF16("my_username"); 983 form.username_value = ASCIIToUTF16("my_username");
979 form.password_value = ASCIIToUTF16("my_password"); 984 form.password_value = ASCIIToUTF16("my_password");
980 form.ssl_valid = false; 985 form.ssl_valid = false;
981 form.preferred = true; 986 form.preferred = true;
982 form.blacklisted_by_user = false; 987 form.blacklisted_by_user = false;
983 form.scheme = PasswordForm::SCHEME_HTML; 988 form.scheme = PasswordForm::SCHEME_HTML;
984 EXPECT_EQ(PasswordStoreChangeList(), db_.AddLogin(form)); 989 EXPECT_EQ(PasswordStoreChangeList(), db().AddLogin(form));
985 990
986 // |signon_realm| shouldn't be empty. 991 // |signon_realm| shouldn't be empty.
987 form.origin = GURL("http://accounts.google.com/LoginAuth"); 992 form.origin = GURL("http://accounts.google.com/LoginAuth");
988 form.signon_realm.clear(); 993 form.signon_realm.clear();
989 EXPECT_EQ(PasswordStoreChangeList(), db_.AddLogin(form)); 994 EXPECT_EQ(PasswordStoreChangeList(), db().AddLogin(form));
990 } 995 }
991 996
992 TEST_F(LoginDatabaseTest, UpdateLogin) { 997 TEST_F(LoginDatabaseTest, UpdateLogin) {
993 PasswordForm form; 998 PasswordForm form;
994 form.origin = GURL("http://accounts.google.com/LoginAuth"); 999 form.origin = GURL("http://accounts.google.com/LoginAuth");
995 form.signon_realm = "http://accounts.google.com/"; 1000 form.signon_realm = "http://accounts.google.com/";
996 form.username_value = ASCIIToUTF16("my_username"); 1001 form.username_value = ASCIIToUTF16("my_username");
997 form.password_value = ASCIIToUTF16("my_password"); 1002 form.password_value = ASCIIToUTF16("my_password");
998 form.ssl_valid = false; 1003 form.ssl_valid = false;
999 form.preferred = true; 1004 form.preferred = true;
1000 form.blacklisted_by_user = false; 1005 form.blacklisted_by_user = false;
1001 form.scheme = PasswordForm::SCHEME_HTML; 1006 form.scheme = PasswordForm::SCHEME_HTML;
1002 EXPECT_EQ(AddChangeForForm(form), db_.AddLogin(form)); 1007 EXPECT_EQ(AddChangeForForm(form), db().AddLogin(form));
1003 1008
1004 form.action = GURL("http://accounts.google.com/login"); 1009 form.action = GURL("http://accounts.google.com/login");
1005 form.password_value = ASCIIToUTF16("my_new_password"); 1010 form.password_value = ASCIIToUTF16("my_new_password");
1006 form.ssl_valid = true; 1011 form.ssl_valid = true;
1007 form.preferred = false; 1012 form.preferred = false;
1008 form.other_possible_usernames.push_back(ASCIIToUTF16("my_new_username")); 1013 form.other_possible_usernames.push_back(ASCIIToUTF16("my_new_username"));
1009 form.times_used = 20; 1014 form.times_used = 20;
1010 form.submit_element = ASCIIToUTF16("submit_element"); 1015 form.submit_element = ASCIIToUTF16("submit_element");
1011 form.date_synced = base::Time::Now(); 1016 form.date_synced = base::Time::Now();
1012 form.date_created = base::Time::Now() - base::TimeDelta::FromDays(1); 1017 form.date_created = base::Time::Now() - base::TimeDelta::FromDays(1);
1013 form.blacklisted_by_user = true; 1018 form.blacklisted_by_user = true;
1014 form.scheme = PasswordForm::SCHEME_BASIC; 1019 form.scheme = PasswordForm::SCHEME_BASIC;
1015 form.type = PasswordForm::TYPE_GENERATED; 1020 form.type = PasswordForm::TYPE_GENERATED;
1016 form.display_name = ASCIIToUTF16("Mr. Smith"); 1021 form.display_name = ASCIIToUTF16("Mr. Smith");
1017 form.avatar_url = GURL("https://accounts.google.com/Avatar"); 1022 form.avatar_url = GURL("https://accounts.google.com/Avatar");
1018 form.federation_url = GURL("https://accounts.google.com/federation"); 1023 form.federation_url = GURL("https://accounts.google.com/federation");
1019 form.is_zero_click = true; 1024 form.is_zero_click = true;
1020 EXPECT_EQ(UpdateChangeForForm(form), db_.UpdateLogin(form)); 1025 EXPECT_EQ(UpdateChangeForForm(form), db().UpdateLogin(form));
1021 1026
1022 ScopedVector<autofill::PasswordForm> result; 1027 ScopedVector<autofill::PasswordForm> result;
1023 EXPECT_TRUE(db_.GetLogins(form, &result.get())); 1028 EXPECT_TRUE(db().GetLogins(form, &result.get()));
1024 ASSERT_EQ(1U, result.size()); 1029 ASSERT_EQ(1U, result.size());
1025 #if defined(OS_MACOSX) && !defined(OS_IOS) 1030 #if defined(OS_MACOSX) && !defined(OS_IOS)
1026 // On Mac, passwords are not stored in login database, instead they're in 1031 // On Mac, passwords are not stored in login database, instead they're in
1027 // the keychain. 1032 // the keychain.
1028 form.password_value.clear(); 1033 form.password_value.clear();
1029 #endif // OS_MACOSX && !OS_IOS 1034 #endif // OS_MACOSX && !OS_IOS
1030 EXPECT_EQ(form, *result[0]); 1035 EXPECT_EQ(form, *result[0]);
1031 } 1036 }
1032 1037
1033 TEST_F(LoginDatabaseTest, ReportMetricsTest) { 1038 TEST_F(LoginDatabaseTest, ReportMetricsTest) {
1034 PasswordForm password_form; 1039 PasswordForm password_form;
1035 password_form.origin = GURL("http://example.com"); 1040 password_form.origin = GURL("http://example.com");
1036 password_form.username_value = ASCIIToUTF16("test1@gmail.com"); 1041 password_form.username_value = ASCIIToUTF16("test1@gmail.com");
1037 password_form.password_value = ASCIIToUTF16("test"); 1042 password_form.password_value = ASCIIToUTF16("test");
1038 password_form.signon_realm = "http://example.com/"; 1043 password_form.signon_realm = "http://example.com/";
1039 password_form.times_used = 0; 1044 password_form.times_used = 0;
1040 EXPECT_EQ(AddChangeForForm(password_form), db_.AddLogin(password_form)); 1045 EXPECT_EQ(AddChangeForForm(password_form), db().AddLogin(password_form));
1041 1046
1042 password_form.username_value = ASCIIToUTF16("test2@gmail.com"); 1047 password_form.username_value = ASCIIToUTF16("test2@gmail.com");
1043 password_form.times_used = 1; 1048 password_form.times_used = 1;
1044 EXPECT_EQ(AddChangeForForm(password_form), db_.AddLogin(password_form)); 1049 EXPECT_EQ(AddChangeForForm(password_form), db().AddLogin(password_form));
1045 1050
1046 password_form.origin = GURL("http://second.example.com"); 1051 password_form.origin = GURL("http://second.example.com");
1047 password_form.signon_realm = "http://second.example.com"; 1052 password_form.signon_realm = "http://second.example.com";
1048 password_form.times_used = 3; 1053 password_form.times_used = 3;
1049 EXPECT_EQ(AddChangeForForm(password_form), db_.AddLogin(password_form)); 1054 EXPECT_EQ(AddChangeForForm(password_form), db().AddLogin(password_form));
1050 1055
1051 password_form.username_value = ASCIIToUTF16("test3@gmail.com"); 1056 password_form.username_value = ASCIIToUTF16("test3@gmail.com");
1052 password_form.type = PasswordForm::TYPE_GENERATED; 1057 password_form.type = PasswordForm::TYPE_GENERATED;
1053 password_form.times_used = 2; 1058 password_form.times_used = 2;
1054 EXPECT_EQ(AddChangeForForm(password_form), db_.AddLogin(password_form)); 1059 EXPECT_EQ(AddChangeForForm(password_form), db().AddLogin(password_form));
1055 1060
1056 password_form.origin = GURL("http://third.example.com/"); 1061 password_form.origin = GURL("http://third.example.com/");
1057 password_form.signon_realm = "http://third.example.com/"; 1062 password_form.signon_realm = "http://third.example.com/";
1058 password_form.times_used = 4; 1063 password_form.times_used = 4;
1059 EXPECT_EQ(AddChangeForForm(password_form), db_.AddLogin(password_form)); 1064 EXPECT_EQ(AddChangeForForm(password_form), db().AddLogin(password_form));
1060 1065
1061 base::HistogramTester histogram_tester; 1066 base::HistogramTester histogram_tester;
1062 db_.ReportMetrics("", false); 1067 db().ReportMetrics("", false);
1063 1068
1064 histogram_tester.ExpectUniqueSample( 1069 histogram_tester.ExpectUniqueSample(
1065 "PasswordManager.TotalAccounts.UserCreated.WithoutCustomPassphrase", 1070 "PasswordManager.TotalAccounts.UserCreated.WithoutCustomPassphrase",
1066 3, 1071 3,
1067 1); 1072 1);
1068 histogram_tester.ExpectBucketCount( 1073 histogram_tester.ExpectBucketCount(
1069 "PasswordManager.AccountsPerSite.UserCreated.WithoutCustomPassphrase", 1074 "PasswordManager.AccountsPerSite.UserCreated.WithoutCustomPassphrase",
1070 1, 1075 1,
1071 1); 1076 1);
1072 histogram_tester.ExpectBucketCount( 1077 histogram_tester.ExpectBucketCount(
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after
1198 ASSERT_EQ(1402955745, date_created[0]); 1203 ASSERT_EQ(1402955745, date_created[0]);
1199 ASSERT_EQ(1402950000, date_created[1]); 1204 ASSERT_EQ(1402950000, date_created[1]);
1200 } else { 1205 } else {
1201 ASSERT_EQ(13047429345000000, date_created[0]); 1206 ASSERT_EQ(13047429345000000, date_created[0]);
1202 ASSERT_EQ(13047423600000000, date_created[1]); 1207 ASSERT_EQ(13047423600000000, date_created[1]);
1203 } 1208 }
1204 1209
1205 { 1210 {
1206 // Assert that the database was successfully opened and updated 1211 // Assert that the database was successfully opened and updated
1207 // to current version. 1212 // to current version.
1208 LoginDatabase db; 1213 LoginDatabase db(database_path_);
1209 ASSERT_TRUE(db.Init(database_path_)); 1214 ASSERT_TRUE(db.Init());
1210 // Verifies that the final version can save all the appropriate fields. 1215 // Verifies that the final version can save all the appropriate fields.
1211 std::vector<PasswordForm*> result; 1216 std::vector<PasswordForm*> result;
1212 PasswordForm form; 1217 PasswordForm form;
1213 GenerateExamplePasswordForm(&form); 1218 GenerateExamplePasswordForm(&form);
1214 db.AddLogin(form); 1219 db.AddLogin(form);
1215 EXPECT_TRUE(db.GetLogins(form, &result)); 1220 EXPECT_TRUE(db.GetLogins(form, &result));
1216 ASSERT_EQ(1U, result.size()); 1221 ASSERT_EQ(1U, result.size());
1217 FormsAreEqual(form, *result[0]); 1222 FormsAreEqual(form, *result[0]);
1218 EXPECT_TRUE(db.RemoveLogin(form)); 1223 EXPECT_TRUE(db.RemoveLogin(form));
1219 delete result[0]; 1224 delete result[0];
1220 result.clear(); 1225 result.clear();
1221 } 1226 }
1222 // New date, in microseconds since platform independent epoch. 1227 // New date, in microseconds since platform independent epoch.
1223 std::vector<int64_t> new_date_created(GetDateCreated()); 1228 std::vector<int64_t> new_date_created(GetDateCreated());
1224 ASSERT_EQ(13047429345000000, new_date_created[0]); 1229 ASSERT_EQ(13047429345000000, new_date_created[0]);
1225 ASSERT_EQ(13047423600000000, new_date_created[1]); 1230 ASSERT_EQ(13047423600000000, new_date_created[1]);
1226 if (table_version <= 8) { 1231 if (table_version <= 8) {
1227 // Check that the two dates match up. 1232 // Check that the two dates match up.
1228 for (size_t i = 0; i < date_created.size(); ++i) { 1233 for (size_t i = 0; i < date_created.size(); ++i) {
1229 EXPECT_EQ(base::Time::FromInternalValue(new_date_created[i]), 1234 EXPECT_EQ(base::Time::FromInternalValue(new_date_created[i]),
1230 base::Time::FromTimeT(date_created[i])); 1235 base::Time::FromTimeT(date_created[i]));
1231 } 1236 }
1232 } 1237 }
1233 DestroyDatabase(); 1238 DestroyDatabase();
1234 } 1239 }
1235 } 1240 }
1236 1241
1237 } // namespace password_manager 1242 } // namespace password_manager
OLDNEW
« no previous file with comments | « components/password_manager/core/browser/login_database.cc ('k') | components/password_manager/core/browser/password_store.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698