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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/renderer/form_manager_unittest.cc

Issue 3150034: GTTF: move tests that use WebKit from unit_tests to browser_tests... (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: '' Created 10 years, 4 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 | Annotate | Revision Log
« no previous file with comments | « chrome/renderer/form_manager_browsertest.cc ('k') | chrome/renderer/pepper_devices_browsertest.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/string_util.h"
6 #include "base/utf_string_conversions.h"
7 #include "chrome/renderer/form_manager.h"
8 #include "chrome/test/render_view_test.h"
9 #include "testing/gtest/include/gtest/gtest.h"
10 #include "third_party/WebKit/WebKit/chromium/public/WebDocument.h"
11 #include "third_party/WebKit/WebKit/chromium/public/WebElement.h"
12 #include "third_party/WebKit/WebKit/chromium/public/WebFormControlElement.h"
13 #include "third_party/WebKit/WebKit/chromium/public/WebFormElement.h"
14 #include "third_party/WebKit/WebKit/chromium/public/WebInputElement.h"
15 #include "third_party/WebKit/WebKit/chromium/public/WebNode.h"
16 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
17 #include "third_party/WebKit/WebKit/chromium/public/WebVector.h"
18 #include "webkit/glue/form_data.h"
19
20 using WebKit::WebDocument;
21 using WebKit::WebElement;
22 using WebKit::WebFormControlElement;
23 using WebKit::WebFormElement;
24 using WebKit::WebFrame;
25 using WebKit::WebInputElement;
26 using WebKit::WebNode;
27 using WebKit::WebString;
28 using WebKit::WebVector;
29
30 using webkit_glue::FormData;
31 using webkit_glue::FormField;
32
33 namespace {
34
35 typedef RenderViewTest FormManagerTest;
36
37 TEST_F(FormManagerTest, WebFormElementToFormData) {
38 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
39 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
40 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
41 " <INPUT type=\"hidden\" id=\"notvisible\" value=\"apple\"/>"
42 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
43 "</FORM>");
44
45 WebFrame* frame = GetMainFrame();
46 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
47
48 WebVector<WebFormElement> forms;
49 frame->forms(forms);
50 ASSERT_EQ(1U, forms.size());
51
52 FormData form;
53 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
54 FormManager::REQUIRE_NONE,
55 true,
56 &form));
57 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
58 EXPECT_EQ(GURL(frame->url()), form.origin);
59 EXPECT_EQ(GURL("http://cnn.com"), form.action);
60
61 const std::vector<FormField>& fields = form.fields;
62 ASSERT_EQ(4U, fields.size());
63 EXPECT_TRUE(fields[0].StrictlyEqualsHack(
64 FormField(string16(),
65 ASCIIToUTF16("firstname"),
66 ASCIIToUTF16("John"),
67 ASCIIToUTF16("text"),
68 20)));
69 EXPECT_TRUE(fields[1].StrictlyEqualsHack(
70 FormField(string16(),
71 ASCIIToUTF16("lastname"),
72 ASCIIToUTF16("Smith"),
73 ASCIIToUTF16("text"),
74 20)));
75 EXPECT_TRUE(fields[2].StrictlyEqualsHack(
76 FormField(string16(),
77 ASCIIToUTF16("notvisible"),
78 ASCIIToUTF16("apple"),
79 ASCIIToUTF16("hidden"),
80 0)));
81 EXPECT_TRUE(fields[3].StrictlyEqualsHack(
82 FormField(string16(),
83 ASCIIToUTF16("reply-send"),
84 string16(),
85 ASCIIToUTF16("submit"),
86 0)));
87 }
88
89 TEST_F(FormManagerTest, ExtractForms) {
90 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
91 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
92 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
93 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
94 "</FORM>");
95
96 WebFrame* web_frame = GetMainFrame();
97 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
98
99 FormManager form_manager;
100 form_manager.ExtractForms(web_frame);
101
102 std::vector<FormData> forms;
103 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
104 ASSERT_EQ(1U, forms.size());
105
106 const FormData& form = forms[0];
107 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
108 EXPECT_EQ(GURL(web_frame->url()), form.origin);
109 EXPECT_EQ(GURL("http://cnn.com"), form.action);
110
111 const std::vector<FormField>& fields = form.fields;
112 ASSERT_EQ(3U, fields.size());
113 EXPECT_EQ(FormField(string16(),
114 ASCIIToUTF16("firstname"),
115 ASCIIToUTF16("John"),
116 ASCIIToUTF16("text"),
117 20),
118 fields[0]);
119 EXPECT_EQ(FormField(string16(),
120 ASCIIToUTF16("lastname"),
121 ASCIIToUTF16("Smith"),
122 ASCIIToUTF16("text"),
123 20),
124 fields[1]);
125 EXPECT_EQ(FormField(string16(),
126 ASCIIToUTF16("reply-send"),
127 ASCIIToUTF16("Send"),
128 ASCIIToUTF16("submit"),
129 0),
130 fields[2]);
131 }
132
133 TEST_F(FormManagerTest, ExtractMultipleForms) {
134 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
135 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
136 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
137 "</FORM>"
138 "<FORM name=\"TestForm2\" action=\"http://zoo.com\" method=\"post\">"
139 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
140 " <INPUT type=\"submit\" name=\"second\" value=\"Submit\"/>"
141 "</FORM>");
142
143 WebFrame* web_frame = GetMainFrame();
144 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
145
146 FormManager form_manager;
147 form_manager.ExtractForms(web_frame);
148
149 std::vector<FormData> forms;
150 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
151 ASSERT_EQ(2U, forms.size());
152
153 // First form.
154 const FormData& form = forms[0];
155 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
156 EXPECT_EQ(GURL(web_frame->url()), form.origin);
157 EXPECT_EQ(GURL("http://cnn.com"), form.action);
158
159 const std::vector<FormField>& fields = form.fields;
160 ASSERT_EQ(2U, fields.size());
161 EXPECT_EQ(FormField(string16(),
162 ASCIIToUTF16("firstname"),
163 ASCIIToUTF16("John"),
164 ASCIIToUTF16("text"),
165 20),
166 fields[0]);
167 EXPECT_EQ(FormField(string16(),
168 ASCIIToUTF16("reply-send"),
169 ASCIIToUTF16("Send"),
170 ASCIIToUTF16("submit"),
171 0),
172 fields[1]);
173
174 // Second form.
175 const FormData& form2 = forms[1];
176 EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name);
177 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
178 EXPECT_EQ(GURL("http://zoo.com"), form2.action);
179
180 const std::vector<FormField>& fields2 = form2.fields;
181 ASSERT_EQ(2U, fields2.size());
182 EXPECT_EQ(FormField(string16(),
183 ASCIIToUTF16("lastname"),
184 ASCIIToUTF16("Smith"),
185 ASCIIToUTF16("text"),
186 20),
187 fields2[0]);
188 EXPECT_EQ(FormField(string16(),
189 ASCIIToUTF16("second"),
190 ASCIIToUTF16("Submit"),
191 ASCIIToUTF16("submit"),
192 0),
193 fields2[1]);
194 }
195
196 TEST_F(FormManagerTest, GetFormsAutocomplete) {
197 // Form is not auto-completable due to autocomplete=off.
198 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\""
199 " autocomplete=off>"
200 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
201 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
202 "</FORM>");
203
204 WebFrame* web_frame = GetMainFrame();
205 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
206
207 FormManager form_manager;
208 form_manager.ExtractForms(web_frame);
209
210 // Verify that we did load the forms.
211 std::vector<FormData> forms;
212 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
213 ASSERT_EQ(1U, forms.size());
214
215 // autocomplete=off and we're requiring autocomplete, so no forms returned.
216 forms.clear();
217 form_manager.GetForms(FormManager::REQUIRE_AUTOCOMPLETE, &forms);
218 ASSERT_EQ(0U, forms.size());
219
220 // The firstname element is not auto-completable due to autocomplete=off.
221 LoadHTML("<FORM name=\"TestForm\" action=\"http://abc.com\" method=\"post\">"
222 " <INPUT type=\"text\" id=\"firstname\" value=\"John\""
223 " autocomplete=off>"
224 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
225 " <INPUT type=\"submit\" name=\"reply\" value=\"Send\"/>"
226 "</FORM>");
227
228 web_frame = GetMainFrame();
229 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
230
231 form_manager.Reset();
232 form_manager.ExtractForms(web_frame);
233
234 forms.clear();
235 form_manager.GetForms(FormManager::REQUIRE_AUTOCOMPLETE, &forms);
236 ASSERT_EQ(1U, forms.size());
237
238 const FormData& form = forms[0];
239 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
240 EXPECT_EQ(GURL(web_frame->url()), form.origin);
241 EXPECT_EQ(GURL("http://abc.com"), form.action);
242
243 const std::vector<FormField>& fields = form.fields;
244 ASSERT_EQ(2U, fields.size());
245 EXPECT_EQ(FormField(string16(),
246 ASCIIToUTF16("lastname"),
247 ASCIIToUTF16("Smith"),
248 ASCIIToUTF16("text"),
249 20),
250 fields[0]);
251 EXPECT_EQ(FormField(string16(),
252 ASCIIToUTF16("reply"),
253 ASCIIToUTF16("Send"),
254 ASCIIToUTF16("submit"),
255 0),
256 fields[1]);
257 }
258
259 TEST_F(FormManagerTest, GetFormsElementsEnabled) {
260 // The firstname element is not enabled due to disabled being set.
261 LoadHTML("<FORM name=\"TestForm\" action=\"http://xyz.com\" method=\"post\">"
262 " <INPUT disabled type=\"text\" id=\"firstname\" value=\"John\"/>"
263 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
264 " <INPUT type=\"submit\" name=\"submit\" value=\"Send\"/>"
265 "</FORM>");
266
267 WebFrame* web_frame = GetMainFrame();
268 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
269
270 FormManager form_manager;
271 form_manager.ExtractForms(web_frame);
272
273 std::vector<FormData> forms;
274 form_manager.GetForms(FormManager::REQUIRE_ENABLED, &forms);
275 ASSERT_EQ(1U, forms.size());
276
277 const FormData& form = forms[0];
278 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
279 EXPECT_EQ(GURL(web_frame->url()), form.origin);
280 EXPECT_EQ(GURL("http://xyz.com"), form.action);
281
282 const std::vector<FormField>& fields = form.fields;
283 ASSERT_EQ(2U, fields.size());
284 EXPECT_EQ(FormField(string16(),
285 ASCIIToUTF16("lastname"),
286 ASCIIToUTF16("Smith"),
287 ASCIIToUTF16("text"),
288 20),
289 fields[0]);
290 EXPECT_EQ(FormField(string16(),
291 ASCIIToUTF16("submit"),
292 ASCIIToUTF16("Send"),
293 ASCIIToUTF16("submit"),
294 0),
295 fields[1]);
296 }
297
298 TEST_F(FormManagerTest, FindForm) {
299 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
300 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
301 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
302 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
303 "</FORM>");
304
305 WebFrame* web_frame = GetMainFrame();
306 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
307
308 FormManager form_manager;
309 form_manager.ExtractForms(web_frame);
310
311 // Verify that we have the form.
312 std::vector<FormData> forms;
313 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
314 ASSERT_EQ(1U, forms.size());
315
316 // Get the input element we want to find.
317 WebElement element = web_frame->document().getElementById("firstname");
318 WebInputElement input_element = element.to<WebInputElement>();
319
320 // Find the form and verify it's the correct form.
321 FormData form;
322 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
323 input_element, FormManager::REQUIRE_NONE, &form));
324 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
325 EXPECT_EQ(GURL(web_frame->url()), form.origin);
326 EXPECT_EQ(GURL("http://buh.com"), form.action);
327
328 const std::vector<FormField>& fields = form.fields;
329 ASSERT_EQ(3U, fields.size());
330 EXPECT_EQ(FormField(string16(),
331 ASCIIToUTF16("firstname"),
332 ASCIIToUTF16("John"),
333 ASCIIToUTF16("text"),
334 20),
335 fields[0]);
336 EXPECT_EQ(FormField(string16(),
337 ASCIIToUTF16("lastname"),
338 ASCIIToUTF16("Smith"),
339 ASCIIToUTF16("text"),
340 20),
341 fields[1]);
342 EXPECT_EQ(FormField(string16(),
343 ASCIIToUTF16("reply-send"),
344 ASCIIToUTF16("Send"),
345 ASCIIToUTF16("submit"),
346 0),
347 fields[2]);
348 }
349
350 TEST_F(FormManagerTest, FillForm) {
351 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
352 " <INPUT type=\"text\" id=\"firstname\"/>"
353 " <INPUT type=\"text\" id=\"lastname\"/>"
354 " <INPUT type=\"hidden\" id=\"imhidden\"/>"
355 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
356 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>"
357 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>"
358 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
359 "</FORM>");
360
361 WebFrame* web_frame = GetMainFrame();
362 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
363
364 FormManager form_manager;
365 form_manager.ExtractForms(web_frame);
366
367 // Verify that we have the form.
368 std::vector<FormData> forms;
369 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
370 ASSERT_EQ(1U, forms.size());
371
372 // Get the input element we want to find.
373 WebElement element = web_frame->document().getElementById("firstname");
374 WebInputElement input_element = element.to<WebInputElement>();
375
376 // Find the form that contains the input element.
377 FormData form;
378 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
379 input_element, FormManager::REQUIRE_NONE, &form));
380 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
381 EXPECT_EQ(GURL(web_frame->url()), form.origin);
382 EXPECT_EQ(GURL("http://buh.com"), form.action);
383
384 const std::vector<FormField>& fields = form.fields;
385 ASSERT_EQ(7U, fields.size());
386 EXPECT_EQ(FormField(string16(),
387 ASCIIToUTF16("firstname"),
388 string16(),
389 ASCIIToUTF16("text"),
390 20),
391 fields[0]);
392 EXPECT_EQ(FormField(string16(),
393 ASCIIToUTF16("lastname"),
394 string16(),
395 ASCIIToUTF16("text"),
396 20),
397 fields[1]);
398 EXPECT_EQ(FormField(string16(),
399 ASCIIToUTF16("imhidden"),
400 string16(),
401 ASCIIToUTF16("hidden"),
402 0),
403 fields[2]);
404 EXPECT_EQ(FormField(string16(),
405 ASCIIToUTF16("notempty"),
406 ASCIIToUTF16("Hi"),
407 ASCIIToUTF16("text"),
408 20),
409 fields[3]);
410 EXPECT_EQ(FormField(string16(),
411 ASCIIToUTF16("noautocomplete"),
412 string16(),
413 ASCIIToUTF16("text"),
414 20),
415 fields[4]);
416 EXPECT_EQ(FormField(string16(),
417 ASCIIToUTF16("notenabled"),
418 string16(),
419 ASCIIToUTF16("text"),
420 20),
421 fields[5]);
422 EXPECT_EQ(FormField(string16(),
423 ASCIIToUTF16("reply-send"),
424 ASCIIToUTF16("Send"),
425 ASCIIToUTF16("submit"),
426 0),
427 fields[6]);
428
429 // Fill the form.
430 form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
431 form.fields[1].set_value(ASCIIToUTF16("Earp"));
432 form.fields[2].set_value(ASCIIToUTF16("Alpha"));
433 form.fields[3].set_value(ASCIIToUTF16("Beta"));
434 form.fields[4].set_value(ASCIIToUTF16("Gamma"));
435 form.fields[5].set_value(ASCIIToUTF16("Delta"));
436 EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
437
438 // Verify the filled elements.
439 WebDocument document = web_frame->document();
440 WebInputElement firstname =
441 document.getElementById("firstname").to<WebInputElement>();
442 EXPECT_TRUE(firstname.isAutofilled());
443 EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
444
445 WebInputElement lastname =
446 document.getElementById("lastname").to<WebInputElement>();
447 EXPECT_TRUE(lastname.isAutofilled());
448 EXPECT_EQ(ASCIIToUTF16("Earp"), lastname.value());
449
450 // Hidden fields are not filled.
451 WebInputElement imhidden =
452 document.getElementById("imhidden").to<WebInputElement>();
453 EXPECT_FALSE(imhidden.isAutofilled());
454 EXPECT_TRUE(imhidden.value().isEmpty());
455
456 // Non-empty fields are not filled.
457 WebInputElement notempty =
458 document.getElementById("notempty").to<WebInputElement>();
459 EXPECT_FALSE(notempty.isAutofilled());
460 EXPECT_EQ(ASCIIToUTF16("Hi"), notempty.value());
461
462 // autocomplete=off fields are not filled.
463 WebInputElement noautocomplete =
464 document.getElementById("noautocomplete").to<WebInputElement>();
465 EXPECT_FALSE(noautocomplete.isAutofilled());
466 EXPECT_TRUE(noautocomplete.value().isEmpty());
467
468 // Disabled fields are not filled.
469 WebInputElement notenabled =
470 document.getElementById("notenabled").to<WebInputElement>();
471 EXPECT_FALSE(notenabled.isAutofilled());
472 EXPECT_TRUE(notenabled.value().isEmpty());
473 }
474
475 TEST_F(FormManagerTest, PreviewForm) {
476 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
477 " <INPUT type=\"text\" id=\"firstname\"/>"
478 " <INPUT type=\"text\" id=\"lastname\"/>"
479 " <INPUT type=\"hidden\" id=\"imhidden\"/>"
480 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
481 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>"
482 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>"
483 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
484 "</FORM>");
485
486 WebFrame* web_frame = GetMainFrame();
487 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
488
489 FormManager form_manager;
490 form_manager.ExtractForms(web_frame);
491
492 // Verify that we have the form.
493 std::vector<FormData> forms;
494 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
495 ASSERT_EQ(1U, forms.size());
496
497 // Get the input element we want to find.
498 WebElement element = web_frame->document().getElementById("firstname");
499 WebInputElement input_element = element.to<WebInputElement>();
500
501 // Find the form that contains the input element.
502 FormData form;
503 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
504 input_element, FormManager::REQUIRE_NONE, &form));
505 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
506 EXPECT_EQ(GURL(web_frame->url()), form.origin);
507 EXPECT_EQ(GURL("http://buh.com"), form.action);
508
509 const std::vector<FormField>& fields = form.fields;
510 ASSERT_EQ(7U, fields.size());
511 EXPECT_EQ(FormField(string16(),
512 ASCIIToUTF16("firstname"),
513 string16(),
514 ASCIIToUTF16("text"),
515 20),
516 fields[0]);
517 EXPECT_EQ(FormField(string16(),
518 ASCIIToUTF16("lastname"),
519 string16(),
520 ASCIIToUTF16("text"),
521 20),
522 fields[1]);
523 EXPECT_EQ(FormField(string16(),
524 ASCIIToUTF16("imhidden"),
525 string16(),
526 ASCIIToUTF16("hidden"),
527 0),
528 fields[2]);
529 EXPECT_EQ(FormField(string16(),
530 ASCIIToUTF16("notempty"),
531 ASCIIToUTF16("Hi"),
532 ASCIIToUTF16("text"),
533 20),
534 fields[3]);
535 EXPECT_EQ(FormField(string16(),
536 ASCIIToUTF16("noautocomplete"),
537 string16(),
538 ASCIIToUTF16("text"),
539 20),
540 fields[4]);
541 EXPECT_EQ(FormField(string16(),
542 ASCIIToUTF16("notenabled"),
543 string16(),
544 ASCIIToUTF16("text"),
545 20),
546 fields[5]);
547 EXPECT_EQ(FormField(string16(),
548 ASCIIToUTF16("reply-send"),
549 ASCIIToUTF16("Send"),
550 ASCIIToUTF16("submit"),
551 0),
552 fields[6]);
553
554 // Preview the form.
555 form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
556 form.fields[1].set_value(ASCIIToUTF16("Earp"));
557 form.fields[2].set_value(ASCIIToUTF16("Alpha"));
558 form.fields[3].set_value(ASCIIToUTF16("Beta"));
559 form.fields[4].set_value(ASCIIToUTF16("Gamma"));
560 form.fields[5].set_value(ASCIIToUTF16("Delta"));
561 EXPECT_TRUE(form_manager.PreviewForm(form));
562
563 // Verify the previewed elements.
564 WebDocument document = web_frame->document();
565 WebInputElement firstname =
566 document.getElementById("firstname").to<WebInputElement>();
567 EXPECT_TRUE(firstname.isAutofilled());
568 EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.suggestedValue());
569
570 WebInputElement lastname =
571 document.getElementById("lastname").to<WebInputElement>();
572 EXPECT_TRUE(lastname.isAutofilled());
573 EXPECT_EQ(ASCIIToUTF16("Earp"), lastname.suggestedValue());
574
575 // Hidden fields are not previewed.
576 WebInputElement imhidden =
577 document.getElementById("imhidden").to<WebInputElement>();
578 EXPECT_FALSE(imhidden.isAutofilled());
579 EXPECT_TRUE(imhidden.suggestedValue().isEmpty());
580
581 // Non-empty fields are not previewed.
582 WebInputElement notempty =
583 document.getElementById("notempty").to<WebInputElement>();
584 EXPECT_FALSE(notempty.isAutofilled());
585 EXPECT_TRUE(notempty.suggestedValue().isEmpty());
586
587 // autocomplete=off fields are not previewed.
588 WebInputElement noautocomplete =
589 document.getElementById("noautocomplete").to<WebInputElement>();
590 EXPECT_FALSE(noautocomplete.isAutofilled());
591 EXPECT_TRUE(noautocomplete.suggestedValue().isEmpty());
592
593 // Disabled fields are not previewed.
594 WebInputElement notenabled =
595 document.getElementById("notenabled").to<WebInputElement>();
596 EXPECT_FALSE(notenabled.isAutofilled());
597 EXPECT_TRUE(notenabled.suggestedValue().isEmpty());
598 }
599
600 TEST_F(FormManagerTest, Reset) {
601 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
602 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
603 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
604 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
605 "</FORM>");
606
607 WebFrame* web_frame = GetMainFrame();
608 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
609
610 FormManager form_manager;
611 form_manager.ExtractForms(web_frame);
612
613 std::vector<FormData> forms;
614 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
615 ASSERT_EQ(1U, forms.size());
616
617 // There should be no forms after the call to Reset.
618 form_manager.Reset();
619
620 forms.clear();
621 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
622 ASSERT_EQ(0U, forms.size());
623 }
624
625 TEST_F(FormManagerTest, Labels) {
626 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
627 " <LABEL for=\"firstname\"> First name: </LABEL>"
628 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
629 " <LABEL for=\"lastname\"> Last name: </LABEL>"
630 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
631 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
632 "</FORM>");
633
634 WebFrame* web_frame = GetMainFrame();
635 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
636
637 FormManager form_manager;
638 form_manager.ExtractForms(web_frame);
639
640 std::vector<FormData> forms;
641 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
642 ASSERT_EQ(1U, forms.size());
643
644 const FormData& form = forms[0];
645 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
646 EXPECT_EQ(GURL(web_frame->url()), form.origin);
647 EXPECT_EQ(GURL("http://cnn.com"), form.action);
648
649 const std::vector<FormField>& fields = form.fields;
650 ASSERT_EQ(3U, fields.size());
651 EXPECT_TRUE(fields[0].StrictlyEqualsHack(
652 FormField(ASCIIToUTF16("First name:"),
653 ASCIIToUTF16("firstname"),
654 ASCIIToUTF16("John"),
655 ASCIIToUTF16("text"),
656 20)));
657 EXPECT_TRUE(fields[1].StrictlyEqualsHack(
658 FormField(ASCIIToUTF16("Last name:"),
659 ASCIIToUTF16("lastname"),
660 ASCIIToUTF16("Smith"),
661 ASCIIToUTF16("text"),
662 20)));
663 EXPECT_TRUE(fields[2].StrictlyEqualsHack(
664 FormField(string16(),
665 ASCIIToUTF16("reply-send"),
666 string16(),
667 ASCIIToUTF16("submit"),
668 0)));
669 }
670
671 TEST_F(FormManagerTest, LabelsWithSpans) {
672 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
673 " <LABEL for=\"firstname\"><span>First name: </span></LABEL>"
674 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
675 " <LABEL for=\"lastname\"><span>Last name: </span></LABEL>"
676 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
677 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
678 "</FORM>");
679
680 WebFrame* web_frame = GetMainFrame();
681 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
682
683 FormManager form_manager;
684 form_manager.ExtractForms(web_frame);
685
686 std::vector<FormData> forms;
687 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
688 ASSERT_EQ(1U, forms.size());
689
690 const FormData& form = forms[0];
691 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
692 EXPECT_EQ(GURL(web_frame->url()), form.origin);
693 EXPECT_EQ(GURL("http://cnn.com"), form.action);
694
695 const std::vector<FormField>& fields = form.fields;
696 ASSERT_EQ(3U, fields.size());
697 EXPECT_TRUE(fields[0].StrictlyEqualsHack(
698 FormField(ASCIIToUTF16("First name:"),
699 ASCIIToUTF16("firstname"),
700 ASCIIToUTF16("John"),
701 ASCIIToUTF16("text"),
702 20)));
703 EXPECT_TRUE(fields[1].StrictlyEqualsHack(
704 FormField(ASCIIToUTF16("Last name:"),
705 ASCIIToUTF16("lastname"),
706 ASCIIToUTF16("Smith"),
707 ASCIIToUTF16("text"),
708 20)));
709 EXPECT_TRUE(fields[2].StrictlyEqualsHack(
710 FormField(string16(),
711 ASCIIToUTF16("reply-send"),
712 string16(),
713 ASCIIToUTF16("submit"),
714 0)));
715 }
716
717 // This test is different from FormManagerTest.Labels in that the label elements
718 // for= attribute is set to the name of the form control element it is a label
719 // for instead of the id of the form control element. This is invalid because
720 // the for= attribute must be set to the id of the form control element.
721 TEST_F(FormManagerTest, InvalidLabels) {
722 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
723 " <LABEL for=\"firstname\"> First name: </LABEL>"
724 " <INPUT type=\"text\" name=\"firstname\" value=\"John\"/>"
725 " <LABEL for=\"lastname\"> Last name: </LABEL>"
726 " <INPUT type=\"text\" name=\"lastname\" value=\"Smith\"/>"
727 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
728 "</FORM>");
729
730 WebFrame* web_frame = GetMainFrame();
731 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
732
733 FormManager form_manager;
734 form_manager.ExtractForms(web_frame);
735
736 std::vector<FormData> forms;
737 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
738 ASSERT_EQ(1U, forms.size());
739
740 const FormData& form = forms[0];
741 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
742 EXPECT_EQ(GURL(web_frame->url()), form.origin);
743 EXPECT_EQ(GURL("http://cnn.com"), form.action);
744
745 const std::vector<FormField>& fields = form.fields;
746 ASSERT_EQ(3U, fields.size());
747 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
748 ASCIIToUTF16("firstname"),
749 ASCIIToUTF16("John"),
750 ASCIIToUTF16("text"),
751 20)));
752 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
753 ASCIIToUTF16("lastname"),
754 ASCIIToUTF16("Smith"),
755 ASCIIToUTF16("text"),
756 20)));
757 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
758 ASCIIToUTF16("reply-send"),
759 string16(),
760 ASCIIToUTF16("submit"),
761 0)));
762 }
763
764 // This test has three form control elements, only one of which has a label
765 // element associated with it. The first element is disabled because of the
766 // autocomplete=off attribute.
767 TEST_F(FormManagerTest, OneLabelElementFirstControlElementDisabled) {
768 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
769 " First name:"
770 " <INPUT type=\"text\" id=\"firstname\" autocomplete=\"off\"/>"
771 " <LABEL for=\"middlename\">Middle name: </LABEL>"
772 " <INPUT type=\"text\" id=\"middlename\"/>"
773 " Last name:"
774 " <INPUT type=\"text\" id=\"lastname\"/>"
775 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
776 "</FORM>");
777
778 WebFrame* web_frame = GetMainFrame();
779 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
780
781 FormManager form_manager;
782 form_manager.ExtractForms(web_frame);
783
784 std::vector<FormData> forms;
785 form_manager.GetForms(FormManager::REQUIRE_AUTOCOMPLETE, &forms);
786 ASSERT_EQ(1U, forms.size());
787
788 const FormData& form = forms[0];
789 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
790 EXPECT_EQ(GURL(web_frame->url()), form.origin);
791 EXPECT_EQ(GURL("http://cnn.com"), form.action);
792
793 const std::vector<FormField>& fields = form.fields;
794 ASSERT_EQ(3U, fields.size());
795 EXPECT_EQ(FormField(ASCIIToUTF16("Middle name:"),
796 ASCIIToUTF16("middlename"),
797 string16(),
798 ASCIIToUTF16("text"),
799 20),
800 fields[0]);
801 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
802 ASCIIToUTF16("lastname"),
803 string16(),
804 ASCIIToUTF16("text"),
805 20),
806 fields[1]);
807 EXPECT_EQ(FormField(string16(),
808 ASCIIToUTF16("reply-send"),
809 ASCIIToUTF16("Send"),
810 ASCIIToUTF16("submit"),
811 0),
812 fields[2]);
813 }
814
815 // Crashy, http://crbug.com/52731.
816 TEST_F(FormManagerTest, DISABLED_LabelsInferredFromText) {
817 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
818 " First name:"
819 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
820 " Last name:"
821 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
822 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
823 "</FORM>");
824
825 WebFrame* web_frame = GetMainFrame();
826 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
827
828 FormManager form_manager;
829 form_manager.ExtractForms(web_frame);
830
831 std::vector<FormData> forms;
832 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
833 ASSERT_EQ(1U, forms.size());
834
835 const FormData& form = forms[0];
836 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
837 EXPECT_EQ(GURL(web_frame->url()), form.origin);
838 EXPECT_EQ(GURL("http://cnn.com"), form.action);
839
840 const std::vector<FormField>& fields = form.fields;
841 ASSERT_EQ(3U, fields.size());
842 EXPECT_EQ(FormField(ASCIIToUTF16("First name:"),
843 ASCIIToUTF16("firstname"),
844 ASCIIToUTF16("John"),
845 ASCIIToUTF16("text"),
846 20),
847 fields[0]);
848 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
849 ASCIIToUTF16("lastname"),
850 ASCIIToUTF16("Smith"),
851 ASCIIToUTF16("text"),
852 20),
853 fields[1]);
854 EXPECT_EQ(FormField(string16(),
855 ASCIIToUTF16("reply-send"),
856 ASCIIToUTF16("Send"),
857 ASCIIToUTF16("submit"),
858 0),
859 fields[2]);
860 }
861
862 TEST_F(FormManagerTest, LabelsInferredFromTextHidden) {
863 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
864 " First name:"
865 " <INPUT type=\"hidden\" id=\"firstname\" value=\"John\"/>"
866 " Last name:"
867 " <INPUT type=\"hidden\" id=\"lastname\" value=\"Smith\"/>"
868 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
869 "</FORM>");
870
871 WebFrame* web_frame = GetMainFrame();
872 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
873
874 FormManager form_manager;
875 form_manager.ExtractForms(web_frame);
876
877 std::vector<FormData> forms;
878 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
879 ASSERT_EQ(1U, forms.size());
880
881 const FormData& form = forms[0];
882 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
883 EXPECT_EQ(GURL(web_frame->url()), form.origin);
884 EXPECT_EQ(GURL("http://cnn.com"), form.action);
885
886 const std::vector<FormField>& fields = form.fields;
887 ASSERT_EQ(3U, fields.size());
888 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
889 ASCIIToUTF16("firstname"),
890 ASCIIToUTF16("John"),
891 ASCIIToUTF16("hidden"),
892 0)));
893 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
894 ASCIIToUTF16("lastname"),
895 ASCIIToUTF16("Smith"),
896 ASCIIToUTF16("hidden"),
897 0)));
898 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
899 ASCIIToUTF16("reply-send"),
900 string16(),
901 ASCIIToUTF16("submit"),
902 0)));
903 }
904
905 TEST_F(FormManagerTest, LabelsInferredFromParagraph) {
906 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
907 " <P>First name:</P><INPUT type=\"text\" "
908 " id=\"firstname\" value=\"John\"/>"
909 " <P>Last name:</P>"
910 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
911 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
912 "</FORM>");
913
914 WebFrame* web_frame = GetMainFrame();
915 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
916
917 FormManager form_manager;
918 form_manager.ExtractForms(web_frame);
919
920 std::vector<FormData> forms;
921 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
922 ASSERT_EQ(1U, forms.size());
923
924 const FormData& form = forms[0];
925 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
926 EXPECT_EQ(GURL(web_frame->url()), form.origin);
927 EXPECT_EQ(GURL("http://cnn.com"), form.action);
928
929 const std::vector<FormField>& fields = form.fields;
930 ASSERT_EQ(3U, fields.size());
931 EXPECT_EQ(FormField(ASCIIToUTF16("First name:"),
932 ASCIIToUTF16("firstname"),
933 ASCIIToUTF16("John"),
934 ASCIIToUTF16("text"),
935 20),
936 fields[0]);
937 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
938 ASCIIToUTF16("lastname"),
939 ASCIIToUTF16("Smith"),
940 ASCIIToUTF16("text"),
941 20),
942 fields[1]);
943 EXPECT_EQ(FormField(string16(),
944 ASCIIToUTF16("reply-send"),
945 ASCIIToUTF16("Send"),
946 ASCIIToUTF16("submit"),
947 0),
948 fields[2]);
949 }
950
951 TEST_F(FormManagerTest, LabelsInferredFromTableCell) {
952 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
953 "<TABLE>"
954 " <TR>"
955 " <TD>First name:</TD>"
956 " <TD><INPUT type=\"text\" id=\"firstname\" value=\"John\"/></TD>"
957 " </TR>"
958 " <TR>"
959 " <TD>Last name:</TD>"
960 " <TD><INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/></TD>"
961 " </TR>"
962 " <TR>"
963 " <TD></TD>"
964 " <TD>"
965 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
966 " </TD>"
967 " </TR>"
968 "</TABLE>"
969 "</FORM>");
970
971 WebFrame* web_frame = GetMainFrame();
972 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
973
974 FormManager form_manager;
975 form_manager.ExtractForms(web_frame);
976
977 std::vector<FormData> forms;
978 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
979 ASSERT_EQ(1U, forms.size());
980
981 const FormData& form = forms[0];
982 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
983 EXPECT_EQ(GURL(web_frame->url()), form.origin);
984 EXPECT_EQ(GURL("http://cnn.com"), form.action);
985
986 const std::vector<FormField>& fields = form.fields;
987 ASSERT_EQ(3U, fields.size());
988 EXPECT_EQ(FormField(ASCIIToUTF16("First name:"),
989 ASCIIToUTF16("firstname"),
990 ASCIIToUTF16("John"),
991 ASCIIToUTF16("text"),
992 20),
993 fields[0]);
994 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
995 ASCIIToUTF16("lastname"),
996 ASCIIToUTF16("Smith"),
997 ASCIIToUTF16("text"),
998 20),
999 fields[1]);
1000 EXPECT_EQ(FormField(string16(),
1001 ASCIIToUTF16("reply-send"),
1002 ASCIIToUTF16("Send"),
1003 ASCIIToUTF16("submit"),
1004 0),
1005 fields[2]);
1006 }
1007
1008 TEST_F(FormManagerTest, LabelsInferredFromTableCellNested) {
1009 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
1010 "<TABLE>"
1011 " <TR>"
1012 " <TD>"
1013 " <FONT>"
1014 " First name:"
1015 " </FONT>"
1016 " <FONT>"
1017 " Bogus"
1018 " </FONT>"
1019 " </TD>"
1020 " <TD>"
1021 " <FONT>"
1022 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
1023 " </FONT>"
1024 " </TD>"
1025 " </TR>"
1026 " <TR>"
1027 " <TD>"
1028 " <FONT>"
1029 " Last name:"
1030 " </FONT>"
1031 " </TD>"
1032 " <TD>"
1033 " <FONT>"
1034 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
1035 " </FONT>"
1036 " </TD>"
1037 " </TR>"
1038 " <TR>"
1039 " <TD></TD>"
1040 " <TD>"
1041 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1042 " </TD>"
1043 " </TR>"
1044 "</TABLE>"
1045 "</FORM>");
1046
1047 WebFrame* web_frame = GetMainFrame();
1048 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1049
1050 FormManager form_manager;
1051 form_manager.ExtractForms(web_frame);
1052
1053 std::vector<FormData> forms;
1054 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1055 ASSERT_EQ(1U, forms.size());
1056
1057 const FormData& form = forms[0];
1058 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1059 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1060 EXPECT_EQ(GURL("http://cnn.com"), form.action);
1061
1062 const std::vector<FormField>& fields = form.fields;
1063 ASSERT_EQ(3U, fields.size());
1064 EXPECT_EQ(FormField(ASCIIToUTF16("First name:Bogus"),
1065 ASCIIToUTF16("firstname"),
1066 ASCIIToUTF16("John"),
1067 ASCIIToUTF16("text"),
1068 20),
1069 fields[0]);
1070 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
1071 ASCIIToUTF16("lastname"),
1072 ASCIIToUTF16("Smith"),
1073 ASCIIToUTF16("text"),
1074 20),
1075 fields[1]);
1076 EXPECT_EQ(FormField(string16(),
1077 ASCIIToUTF16("reply-send"),
1078 ASCIIToUTF16("Send"),
1079 ASCIIToUTF16("submit"),
1080 0),
1081 fields[2]);
1082 }
1083
1084 TEST_F(FormManagerTest, LabelsInferredFromDefinitionList) {
1085 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
1086 "<DL>"
1087 " <DT>"
1088 " <SPAN>"
1089 " *"
1090 " </SPAN>"
1091 " <SPAN>"
1092 " First name:"
1093 " </SPAN>"
1094 " <SPAN>"
1095 " Bogus"
1096 " </SPAN>"
1097 " </DT>"
1098 " <DD>"
1099 " <FONT>"
1100 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
1101 " </FONT>"
1102 " </DD>"
1103 " <DT>"
1104 " <SPAN>"
1105 " Last name:"
1106 " </SPAN>"
1107 " </DT>"
1108 " <DD>"
1109 " <FONT>"
1110 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
1111 " </FONT>"
1112 " </DD>"
1113 " <DT></DT>"
1114 " <DD>"
1115 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1116 " </DD>"
1117 "</DL>"
1118 "</FORM>");
1119
1120 WebFrame* web_frame = GetMainFrame();
1121 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1122
1123 FormManager form_manager;
1124 form_manager.ExtractForms(web_frame);
1125
1126 std::vector<FormData> forms;
1127 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1128 ASSERT_EQ(1U, forms.size());
1129
1130 const FormData& form = forms[0];
1131 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1132 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1133 EXPECT_EQ(GURL("http://cnn.com"), form.action);
1134
1135 const std::vector<FormField>& fields = form.fields;
1136 ASSERT_EQ(3U, fields.size());
1137 EXPECT_EQ(FormField(ASCIIToUTF16("*First name:Bogus"),
1138 ASCIIToUTF16("firstname"),
1139 ASCIIToUTF16("John"),
1140 ASCIIToUTF16("text"),
1141 20),
1142 fields[0]);
1143 EXPECT_EQ(FormField(ASCIIToUTF16("Last name:"),
1144 ASCIIToUTF16("lastname"),
1145 ASCIIToUTF16("Smith"),
1146 ASCIIToUTF16("text"),
1147 20),
1148 fields[1]);
1149 EXPECT_EQ(FormField(string16(),
1150 ASCIIToUTF16("reply-send"),
1151 ASCIIToUTF16("Send"),
1152 ASCIIToUTF16("submit"),
1153 0),
1154 fields[2]);
1155 }
1156
1157 TEST_F(FormManagerTest, LabelsInferredWithSameName) {
1158 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
1159 " Address Line 1:"
1160 " <INPUT type=\"text\" name=\"Address\"/>"
1161 " Address Line 2:"
1162 " <INPUT type=\"text\" name=\"Address\"/>"
1163 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1164 "</FORM>");
1165
1166 WebFrame* web_frame = GetMainFrame();
1167 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1168
1169 FormManager form_manager;
1170 form_manager.ExtractForms(web_frame);
1171
1172 std::vector<FormData> forms;
1173 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1174 ASSERT_EQ(1U, forms.size());
1175
1176 const FormData& form = forms[0];
1177 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1178 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1179 EXPECT_EQ(GURL("http://cnn.com"), form.action);
1180
1181 const std::vector<FormField>& fields = form.fields;
1182 ASSERT_EQ(3U, fields.size());
1183 EXPECT_EQ(FormField(ASCIIToUTF16("Address Line 1:"),
1184 ASCIIToUTF16("Address"),
1185 string16(),
1186 ASCIIToUTF16("text"),
1187 20),
1188 fields[0]);
1189 EXPECT_EQ(FormField(ASCIIToUTF16("Address Line 2:"),
1190 ASCIIToUTF16("Address"),
1191 string16(),
1192 ASCIIToUTF16("text"),
1193 20),
1194 fields[1]);
1195 EXPECT_EQ(FormField(string16(),
1196 ASCIIToUTF16("reply-send"),
1197 ASCIIToUTF16("Send"),
1198 ASCIIToUTF16("submit"),
1199 0),
1200 fields[2]);
1201 }
1202
1203 TEST_F(FormManagerTest, LabelsInferredWithImageTags) {
1204 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
1205 " Phone:"
1206 " <input type=\"text\" name=\"dayphone1\">"
1207 " <img/>"
1208 " -"
1209 " <img/>"
1210 " <input type=\"text\" name=\"dayphone2\">"
1211 " <img/>"
1212 " -"
1213 " <img/>"
1214 " <input type=\"text\" name=\"dayphone3\">"
1215 " ext.:"
1216 " <input type=\"text\" name=\"dayphone4\">"
1217 " <input type=\"text\" name=\"dummy\">"
1218 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">"
1219 "</FORM>");
1220
1221 WebFrame* frame = GetMainFrame();
1222 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
1223
1224 WebVector<WebFormElement> forms;
1225 frame->forms(forms);
1226 ASSERT_EQ(1U, forms.size());
1227
1228 FormData form;
1229 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
1230 FormManager::REQUIRE_NONE,
1231 true,
1232 &form));
1233 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1234 EXPECT_EQ(GURL(frame->url()), form.origin);
1235 EXPECT_EQ(GURL("http://cnn.com"), form.action);
1236
1237 const std::vector<FormField>& fields = form.fields;
1238 ASSERT_EQ(6U, fields.size());
1239 EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
1240 ASCIIToUTF16("dayphone1"),
1241 string16(),
1242 ASCIIToUTF16("text"),
1243 20),
1244 fields[0]);
1245 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
1246 ASCIIToUTF16("dayphone2"),
1247 string16(),
1248 ASCIIToUTF16("text"),
1249 20),
1250 fields[1]);
1251 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
1252 ASCIIToUTF16("dayphone3"),
1253 string16(),
1254 ASCIIToUTF16("text"),
1255 20),
1256 fields[2]);
1257 EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
1258 ASCIIToUTF16("dayphone4"),
1259 string16(),
1260 ASCIIToUTF16("text"),
1261 20),
1262 fields[3]);
1263 EXPECT_EQ(FormField(string16(),
1264 ASCIIToUTF16("dummy"),
1265 string16(),
1266 ASCIIToUTF16("text"),
1267 20),
1268 fields[4]);
1269 EXPECT_EQ(FormField(string16(),
1270 ASCIIToUTF16("reply-send"),
1271 ASCIIToUTF16("Send"),
1272 ASCIIToUTF16("submit"),
1273 0),
1274 fields[5]);
1275 }
1276
1277 TEST_F(FormManagerTest, FillFormMaxLength) {
1278 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1279 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"5\"/>"
1280 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"5\"/>"
1281 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1282 "</FORM>");
1283
1284 WebFrame* web_frame = GetMainFrame();
1285 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1286
1287 FormManager form_manager;
1288 form_manager.ExtractForms(web_frame);
1289
1290 // Verify that we have the form.
1291 std::vector<FormData> forms;
1292 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1293 ASSERT_EQ(1U, forms.size());
1294
1295 // Get the input element we want to find.
1296 WebElement element = web_frame->document().getElementById("firstname");
1297 WebInputElement input_element = element.to<WebInputElement>();
1298
1299 // Find the form that contains the input element.
1300 FormData form;
1301 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1302 input_element, FormManager::REQUIRE_NONE, &form));
1303 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1304 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1305 EXPECT_EQ(GURL("http://buh.com"), form.action);
1306
1307 const std::vector<FormField>& fields = form.fields;
1308 ASSERT_EQ(3U, fields.size());
1309 EXPECT_EQ(FormField(string16(),
1310 ASCIIToUTF16("firstname"),
1311 string16(),
1312 ASCIIToUTF16("text"),
1313 20),
1314 fields[0]);
1315 EXPECT_EQ(FormField(string16(),
1316 ASCIIToUTF16("lastname"),
1317 string16(),
1318 ASCIIToUTF16("text"),
1319 20),
1320 fields[1]);
1321 EXPECT_EQ(FormField(string16(),
1322 ASCIIToUTF16("reply-send"),
1323 ASCIIToUTF16("Send"),
1324 ASCIIToUTF16("submit"),
1325 0),
1326 fields[2]);
1327
1328 // Fill the form.
1329 form.fields[0].set_value(ASCIIToUTF16("Brother"));
1330 form.fields[1].set_value(ASCIIToUTF16("Jonathan"));
1331 EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
1332
1333 // Find the newly-filled form that contains the input element.
1334 FormData form2;
1335 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1336 input_element, FormManager::REQUIRE_NONE, &form2));
1337 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1338 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1339 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1340
1341 const std::vector<FormField>& fields2 = form2.fields;
1342 EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
1343 FormField(string16(),
1344 ASCIIToUTF16("firstname"),
1345 ASCIIToUTF16("Broth"),
1346 ASCIIToUTF16("text"),
1347 20)));
1348 EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
1349 FormField(string16(),
1350 ASCIIToUTF16("lastname"),
1351 ASCIIToUTF16("Jonat"),
1352 ASCIIToUTF16("text"),
1353 20)));
1354 EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
1355 FormField(string16(),
1356 ASCIIToUTF16("reply-send"),
1357 string16(),
1358 ASCIIToUTF16("submit"),
1359 0)));
1360 }
1361
1362 // This test uses negative values of the maxlength attribute for input elements.
1363 // In this case, the maxlength of the input elements is set to the default
1364 // maxlength (defined in WebKit.)
1365 TEST_F(FormManagerTest, FillFormNegativeMaxLength) {
1366 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1367 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"-1\"/>"
1368 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"-10\"/>"
1369 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1370 "</FORM>");
1371
1372 WebFrame* web_frame = GetMainFrame();
1373 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1374
1375 FormManager form_manager;
1376 form_manager.ExtractForms(web_frame);
1377
1378 // Verify that we have the form.
1379 std::vector<FormData> forms;
1380 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1381 ASSERT_EQ(1U, forms.size());
1382
1383 // Get the input element we want to find.
1384 WebElement element = web_frame->document().getElementById("firstname");
1385 WebInputElement input_element = element.to<WebInputElement>();
1386
1387 // Find the form that contains the input element.
1388 FormData form;
1389 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1390 input_element, FormManager::REQUIRE_NONE, &form));
1391 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1392 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1393 EXPECT_EQ(GURL("http://buh.com"), form.action);
1394
1395 const std::vector<FormField>& fields = form.fields;
1396 ASSERT_EQ(3U, fields.size());
1397 EXPECT_EQ(FormField(string16(),
1398 ASCIIToUTF16("firstname"),
1399 string16(),
1400 ASCIIToUTF16("text"),
1401 20),
1402 fields[0]);
1403 EXPECT_EQ(FormField(string16(),
1404 ASCIIToUTF16("lastname"),
1405 string16(),
1406 ASCIIToUTF16("text"),
1407 20),
1408 fields[1]);
1409 EXPECT_EQ(FormField(string16(),
1410 ASCIIToUTF16("reply-send"),
1411 ASCIIToUTF16("Send"),
1412 ASCIIToUTF16("submit"),
1413 0),
1414 fields[2]);
1415
1416 // Fill the form.
1417 form.fields[0].set_value(ASCIIToUTF16("Brother"));
1418 form.fields[1].set_value(ASCIIToUTF16("Jonathan"));
1419 EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
1420
1421 // Find the newly-filled form that contains the input element.
1422 FormData form2;
1423 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1424 input_element, FormManager::REQUIRE_NONE, &form2));
1425 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1426 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1427 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1428
1429 const std::vector<FormField>& fields2 = form2.fields;
1430 ASSERT_EQ(3U, fields2.size());
1431 EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
1432 FormField(string16(),
1433 ASCIIToUTF16("firstname"),
1434 ASCIIToUTF16("Brother"),
1435 ASCIIToUTF16("text"),
1436 20)));
1437 EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
1438 FormField(string16(),
1439 ASCIIToUTF16("lastname"),
1440 ASCIIToUTF16("Jonathan"),
1441 ASCIIToUTF16("text"),
1442 20)));
1443 EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
1444 FormField(string16(),
1445 ASCIIToUTF16("reply-send"),
1446 string16(),
1447 ASCIIToUTF16("submit"),
1448 0)));
1449 }
1450
1451 // This test sends a FormData object to FillForm with more fields than are in
1452 // the cached WebFormElement. In this case, we only fill out the fields that
1453 // match between the FormData object and the WebFormElement.
1454 TEST_F(FormManagerTest, FillFormMoreFormDataFields) {
1455 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1456 " <INPUT type=\"text\" id=\"firstname\"/>"
1457 " <INPUT type=\"text\" id=\"middlename\"/>"
1458 " <INPUT type=\"text\" id=\"lastname\"/>"
1459 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1460 "</FORM>");
1461
1462 WebFrame* web_frame = GetMainFrame();
1463 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1464
1465 FormManager form_manager;
1466 form_manager.ExtractForms(web_frame);
1467
1468 // Verify that we have the form.
1469 std::vector<FormData> forms;
1470 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1471 ASSERT_EQ(1U, forms.size());
1472
1473 // After the field modification, the fields in |form| will look like:
1474 // prefix
1475 // firstname
1476 // hidden
1477 // middlename
1478 // second
1479 // lastname
1480 // postfix
1481 FormData* form = &forms[0];
1482
1483 FormField field1(string16(),
1484 ASCIIToUTF16("prefix"),
1485 string16(),
1486 ASCIIToUTF16("text"),
1487 20);
1488 form->fields.insert(form->fields.begin(), field1);
1489
1490 FormField field2(string16(),
1491 ASCIIToUTF16("hidden"),
1492 string16(),
1493 ASCIIToUTF16("text"),
1494 20);
1495 form->fields.insert(form->fields.begin() + 2, field2);
1496
1497 FormField field3(string16(),
1498 ASCIIToUTF16("second"),
1499 string16(),
1500 ASCIIToUTF16("text"),
1501 20);
1502 form->fields.insert(form->fields.begin() + 4, field3);
1503
1504 FormField field4(string16(),
1505 ASCIIToUTF16("postfix"),
1506 string16(),
1507 ASCIIToUTF16("text"),
1508 20);
1509 form->fields.insert(form->fields.begin() + 6, field4);
1510
1511 // Fill the form.
1512 form->fields[0].set_value(ASCIIToUTF16("Alpha"));
1513 form->fields[1].set_value(ASCIIToUTF16("Brother"));
1514 form->fields[2].set_value(ASCIIToUTF16("Abracadabra"));
1515 form->fields[3].set_value(ASCIIToUTF16("Joseph"));
1516 form->fields[4].set_value(ASCIIToUTF16("Beta"));
1517 form->fields[5].set_value(ASCIIToUTF16("Jonathan"));
1518 form->fields[6].set_value(ASCIIToUTF16("Omega"));
1519 EXPECT_TRUE(form_manager.FillForm(*form, WebNode()));
1520
1521 // Get the input element we want to find.
1522 WebElement element = web_frame->document().getElementById("firstname");
1523 WebInputElement input_element = element.to<WebInputElement>();
1524
1525 // Find the newly-filled form that contains the input element.
1526 FormData form2;
1527 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1528 input_element, FormManager::REQUIRE_NONE, &form2));
1529 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1530 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1531 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1532
1533 const std::vector<FormField>& fields = form2.fields;
1534 ASSERT_EQ(4U, fields.size());
1535 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
1536 ASCIIToUTF16("firstname"),
1537 ASCIIToUTF16("Brother"),
1538 ASCIIToUTF16("text"),
1539 20)));
1540 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
1541 ASCIIToUTF16("middlename"),
1542 ASCIIToUTF16("Joseph"),
1543 ASCIIToUTF16("text"),
1544 20)));
1545 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
1546 ASCIIToUTF16("lastname"),
1547 ASCIIToUTF16("Jonathan"),
1548 ASCIIToUTF16("text"),
1549 20)));
1550 EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
1551 ASCIIToUTF16("reply-send"),
1552 string16(),
1553 ASCIIToUTF16("submit"),
1554 0)));
1555 }
1556
1557 // This test sends a FormData object to FillForm with fewer fields than are in
1558 // the cached WebFormElement. In this case, we only fill out the fields that
1559 // match between the FormData object and the WebFormElement.
1560 TEST_F(FormManagerTest, FillFormFewerFormDataFields) {
1561 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1562 " <INPUT type=\"text\" id=\"prefix\"/>"
1563 " <INPUT type=\"text\" id=\"firstname\"/>"
1564 " <INPUT type=\"text\" id=\"hidden\"/>"
1565 " <INPUT type=\"text\" id=\"middlename\"/>"
1566 " <INPUT type=\"text\" id=\"second\"/>"
1567 " <INPUT type=\"text\" id=\"lastname\"/>"
1568 " <INPUT type=\"text\" id=\"postfix\"/>"
1569 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1570 "</FORM>");
1571
1572 WebFrame* web_frame = GetMainFrame();
1573 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1574
1575 FormManager form_manager;
1576 form_manager.ExtractForms(web_frame);
1577
1578 // Verify that we have the form.
1579 std::vector<FormData> forms;
1580 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1581 ASSERT_EQ(1U, forms.size());
1582
1583 // After the field modification, the fields in |form| will look like:
1584 // firstname
1585 // middlename
1586 // lastname
1587 FormData* form = &forms[0];
1588 form->fields.erase(form->fields.begin());
1589 form->fields.erase(form->fields.begin() + 1);
1590 form->fields.erase(form->fields.begin() + 2);
1591 form->fields.erase(form->fields.begin() + 3);
1592
1593 // Fill the form.
1594 form->fields[0].set_value(ASCIIToUTF16("Brother"));
1595 form->fields[1].set_value(ASCIIToUTF16("Joseph"));
1596 form->fields[2].set_value(ASCIIToUTF16("Jonathan"));
1597 EXPECT_TRUE(form_manager.FillForm(*form, WebNode()));
1598
1599 // Get the input element we want to find.
1600 WebElement element = web_frame->document().getElementById("firstname");
1601 WebInputElement input_element = element.to<WebInputElement>();
1602
1603 // Find the newly-filled form that contains the input element.
1604 FormData form2;
1605 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1606 input_element, FormManager::REQUIRE_NONE, &form2));
1607 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1608 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1609 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1610
1611 const std::vector<FormField>& fields = form2.fields;
1612 ASSERT_EQ(8U, fields.size());
1613 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
1614 ASCIIToUTF16("prefix"),
1615 string16(),
1616 ASCIIToUTF16("text"),
1617 20)));
1618 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
1619 ASCIIToUTF16("firstname"),
1620 ASCIIToUTF16("Brother"),
1621 ASCIIToUTF16("text"),
1622 20)));
1623 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
1624 ASCIIToUTF16("hidden"),
1625 string16(),
1626 ASCIIToUTF16("text"),
1627 20)));
1628 EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
1629 ASCIIToUTF16("middlename"),
1630 ASCIIToUTF16("Joseph"),
1631 ASCIIToUTF16("text"),
1632 20)));
1633 EXPECT_TRUE(fields[4].StrictlyEqualsHack(FormField(string16(),
1634 ASCIIToUTF16("second"),
1635 string16(),
1636 ASCIIToUTF16("text"),
1637 20)));
1638 EXPECT_TRUE(fields[5].StrictlyEqualsHack(FormField(string16(),
1639 ASCIIToUTF16("lastname"),
1640 ASCIIToUTF16("Jonathan"),
1641 ASCIIToUTF16("text"),
1642 20)));
1643 EXPECT_TRUE(fields[6].StrictlyEqualsHack(FormField(string16(),
1644 ASCIIToUTF16("postfix"),
1645 string16(),
1646 ASCIIToUTF16("text"),
1647 20)));
1648 EXPECT_TRUE(fields[7].StrictlyEqualsHack(FormField(string16(),
1649 ASCIIToUTF16("reply-send"),
1650 string16(),
1651 ASCIIToUTF16("submit"),
1652 0)));
1653 }
1654
1655 // This test sends a FormData object to FillForm with a field changed from
1656 // those in the cached WebFormElement. In this case, we only fill out the
1657 // fields that match between the FormData object and the WebFormElement.
1658 TEST_F(FormManagerTest, FillFormChangedFormDataFields) {
1659 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1660 " <INPUT type=\"text\" id=\"firstname\"/>"
1661 " <INPUT type=\"text\" id=\"middlename\"/>"
1662 " <INPUT type=\"text\" id=\"lastname\"/>"
1663 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1664 "</FORM>");
1665
1666 WebFrame* web_frame = GetMainFrame();
1667 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1668
1669 FormManager form_manager;
1670 form_manager.ExtractForms(web_frame);
1671
1672 // Verify that we have the form.
1673 std::vector<FormData> forms;
1674 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1675 ASSERT_EQ(1U, forms.size());
1676
1677 // After the field modification, the fields in |form| will look like:
1678 // firstname
1679 // middlename
1680 // lastname
1681 FormData* form = &forms[0];
1682
1683 // Fill the form.
1684 form->fields[0].set_value(ASCIIToUTF16("Brother"));
1685 form->fields[1].set_value(ASCIIToUTF16("Joseph"));
1686 form->fields[2].set_value(ASCIIToUTF16("Jonathan"));
1687
1688 // Alter the label and name used for matching.
1689 form->fields[1].set_label(ASCIIToUTF16("bogus"));
1690 form->fields[1].set_name(ASCIIToUTF16("bogus"));
1691
1692 EXPECT_TRUE(form_manager.FillForm(*form, WebNode()));
1693
1694 // Get the input element we want to find.
1695 WebElement element = web_frame->document().getElementById("firstname");
1696 WebInputElement input_element = element.to<WebInputElement>();
1697
1698 // Find the newly-filled form that contains the input element.
1699 FormData form2;
1700 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1701 input_element, FormManager::REQUIRE_NONE, &form2));
1702 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1703 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1704 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1705
1706 const std::vector<FormField>& fields = form2.fields;
1707 ASSERT_EQ(4U, fields.size());
1708 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
1709 ASCIIToUTF16("firstname"),
1710 ASCIIToUTF16("Brother"),
1711 ASCIIToUTF16("text"),
1712 20)));
1713 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
1714 ASCIIToUTF16("middlename"),
1715 string16(),
1716 ASCIIToUTF16("text"),
1717 20)));
1718 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
1719 ASCIIToUTF16("lastname"),
1720 ASCIIToUTF16("Jonathan"),
1721 ASCIIToUTF16("text"),
1722 20)));
1723 EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
1724 ASCIIToUTF16("reply-send"),
1725 string16(),
1726 ASCIIToUTF16("submit"),
1727 0)));
1728 }
1729
1730 // This test sends a FormData object to FillForm with fewer fields than are in
1731 // the cached WebFormElement. In this case, we only fill out the fields that
1732 // match between the FormData object and the WebFormElement.
1733 TEST_F(FormManagerTest, FillFormExtraFieldInCache) {
1734 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1735 " <INPUT type=\"text\" id=\"firstname\"/>"
1736 " <INPUT type=\"text\" id=\"middlename\"/>"
1737 " <INPUT type=\"text\" id=\"lastname\"/>"
1738 " <INPUT type=\"text\" id=\"postfix\"/>"
1739 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1740 "</FORM>");
1741
1742 WebFrame* web_frame = GetMainFrame();
1743 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1744
1745 FormManager form_manager;
1746 form_manager.ExtractForms(web_frame);
1747
1748 // Verify that we have the form.
1749 std::vector<FormData> forms;
1750 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1751 ASSERT_EQ(1U, forms.size());
1752
1753 // After the field modification, the fields in |form| will look like:
1754 // firstname
1755 // middlename
1756 // lastname
1757 FormData* form = &forms[0];
1758 form->fields.pop_back();
1759
1760 // Fill the form.
1761 form->fields[0].set_value(ASCIIToUTF16("Brother"));
1762 form->fields[1].set_value(ASCIIToUTF16("Joseph"));
1763 form->fields[2].set_value(ASCIIToUTF16("Jonathan"));
1764 EXPECT_TRUE(form_manager.FillForm(*form, WebNode()));
1765
1766 // Get the input element we want to find.
1767 WebElement element = web_frame->document().getElementById("firstname");
1768 WebInputElement input_element = element.to<WebInputElement>();
1769
1770 // Find the newly-filled form that contains the input element.
1771 FormData form2;
1772 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1773 input_element, FormManager::REQUIRE_NONE, &form2));
1774 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1775 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1776 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1777
1778 const std::vector<FormField>& fields = form2.fields;
1779 ASSERT_EQ(5U, fields.size());
1780 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
1781 ASCIIToUTF16("firstname"),
1782 ASCIIToUTF16("Brother"),
1783 ASCIIToUTF16("text"),
1784 20)));
1785 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
1786 ASCIIToUTF16("middlename"),
1787 ASCIIToUTF16("Joseph"),
1788 ASCIIToUTF16("text"),
1789 20)));
1790 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
1791 ASCIIToUTF16("lastname"),
1792 ASCIIToUTF16("Jonathan"),
1793 ASCIIToUTF16("text"),
1794 20)));
1795 EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
1796 ASCIIToUTF16("postfix"),
1797 string16(),
1798 ASCIIToUTF16("text"),
1799 20)));
1800 EXPECT_TRUE(fields[4].StrictlyEqualsHack(FormField(string16(),
1801 ASCIIToUTF16("reply-send"),
1802 string16(),
1803 ASCIIToUTF16("submit"),
1804 0)));
1805 }
1806
1807 TEST_F(FormManagerTest, FillFormEmptyName) {
1808 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1809 " <INPUT type=\"text\" id=\"firstname\"/>"
1810 " <INPUT type=\"text\" id=\"lastname\"/>"
1811 " <INPUT type=\"submit\" value=\"Send\"/>"
1812 "</FORM>");
1813
1814 WebFrame* web_frame = GetMainFrame();
1815 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1816
1817 FormManager form_manager;
1818 form_manager.ExtractForms(web_frame);
1819
1820 // Verify that we have the form.
1821 std::vector<FormData> forms;
1822 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1823 ASSERT_EQ(1U, forms.size());
1824
1825 // Get the input element we want to find.
1826 WebElement element = web_frame->document().getElementById("firstname");
1827 WebInputElement input_element = element.to<WebInputElement>();
1828
1829 // Find the form that contains the input element.
1830 FormData form;
1831 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1832 input_element, FormManager::REQUIRE_NONE, &form));
1833 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1834 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1835 EXPECT_EQ(GURL("http://buh.com"), form.action);
1836
1837 const std::vector<FormField>& fields = form.fields;
1838 ASSERT_EQ(3U, fields.size());
1839 EXPECT_EQ(FormField(string16(),
1840 ASCIIToUTF16("firstname"),
1841 string16(),
1842 ASCIIToUTF16("text"),
1843 20),
1844 fields[0]);
1845 EXPECT_EQ(FormField(string16(),
1846 ASCIIToUTF16("lastname"),
1847 string16(),
1848 ASCIIToUTF16("text"),
1849 20),
1850 fields[1]);
1851 EXPECT_EQ(FormField(string16(),
1852 string16(),
1853 ASCIIToUTF16("Send"),
1854 ASCIIToUTF16("submit"),
1855 0),
1856 fields[2]);
1857
1858 // Fill the form.
1859 form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
1860 form.fields[1].set_value(ASCIIToUTF16("Earp"));
1861 EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
1862
1863 // Find the newly-filled form that contains the input element.
1864 FormData form2;
1865 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1866 input_element, FormManager::REQUIRE_NONE, &form2));
1867 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1868 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1869 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1870
1871 const std::vector<FormField>& fields2 = form2.fields;
1872 ASSERT_EQ(3U, fields2.size());
1873 EXPECT_EQ(FormField(string16(),
1874 ASCIIToUTF16("firstname"),
1875 ASCIIToUTF16("Wyatt"),
1876 ASCIIToUTF16("text"),
1877 20),
1878 fields2[0]);
1879 EXPECT_EQ(FormField(string16(),
1880 ASCIIToUTF16("lastname"),
1881 ASCIIToUTF16("Earp"),
1882 ASCIIToUTF16("text"),
1883 20),
1884 fields2[1]);
1885 EXPECT_EQ(FormField(string16(),
1886 string16(),
1887 ASCIIToUTF16("Send"),
1888 ASCIIToUTF16("submit"),
1889 0),
1890 fields2[2]);
1891 }
1892
1893 TEST_F(FormManagerTest, FillFormEmptyFormNames) {
1894 LoadHTML("<FORM action=\"http://buh.com\" method=\"post\">"
1895 " <INPUT type=\"text\" id=\"firstname\"/>"
1896 " <INPUT type=\"text\" id=\"middlename\"/>"
1897 " <INPUT type=\"text\" id=\"lastname\"/>"
1898 " <INPUT type=\"submit\" value=\"Send\"/>"
1899 "</FORM>"
1900 "<FORM action=\"http://abc.com\" method=\"post\">"
1901 " <INPUT type=\"text\" id=\"apple\"/>"
1902 " <INPUT type=\"text\" id=\"banana\"/>"
1903 " <INPUT type=\"submit\" value=\"Send\"/>"
1904 "</FORM>");
1905
1906 WebFrame* web_frame = GetMainFrame();
1907 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
1908
1909 FormManager form_manager;
1910 form_manager.ExtractForms(web_frame);
1911
1912 // Verify that we have the form.
1913 std::vector<FormData> forms;
1914 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
1915 ASSERT_EQ(2U, forms.size());
1916
1917 // Get the input element we want to find.
1918 WebElement element = web_frame->document().getElementById("apple");
1919 WebInputElement input_element = element.to<WebInputElement>();
1920
1921 // Find the form that contains the input element.
1922 FormData form;
1923 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1924 input_element, FormManager::REQUIRE_NONE, &form));
1925 EXPECT_EQ(string16(), form.name);
1926 EXPECT_EQ(GURL(web_frame->url()), form.origin);
1927 EXPECT_EQ(GURL("http://abc.com"), form.action);
1928
1929 const std::vector<FormField>& fields = form.fields;
1930 ASSERT_EQ(3U, fields.size());
1931 EXPECT_EQ(FormField(string16(),
1932 ASCIIToUTF16("apple"),
1933 string16(),
1934 ASCIIToUTF16("text"),
1935 20),
1936 fields[0]);
1937 EXPECT_EQ(FormField(string16(),
1938 ASCIIToUTF16("banana"),
1939 string16(),
1940 ASCIIToUTF16("text"),
1941 20),
1942 fields[1]);
1943 EXPECT_EQ(FormField(string16(),
1944 string16(),
1945 ASCIIToUTF16("Send"),
1946 ASCIIToUTF16("submit"),
1947 0),
1948 fields[2]);
1949
1950 // Fill the form.
1951 form.fields[0].set_value(ASCIIToUTF16("Red"));
1952 form.fields[1].set_value(ASCIIToUTF16("Yellow"));
1953 EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
1954
1955 // Find the newly-filled form that contains the input element.
1956 FormData form2;
1957 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
1958 input_element, FormManager::REQUIRE_NONE, &form2));
1959 EXPECT_EQ(string16(), form2.name);
1960 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
1961 EXPECT_EQ(GURL("http://abc.com"), form2.action);
1962
1963 const std::vector<FormField>& fields2 = form2.fields;
1964 ASSERT_EQ(3U, fields2.size());
1965 EXPECT_EQ(FormField(string16(),
1966 ASCIIToUTF16("apple"),
1967 ASCIIToUTF16("Red"),
1968 ASCIIToUTF16("text"),
1969 20),
1970 fields2[0]);
1971 EXPECT_EQ(FormField(string16(),
1972 ASCIIToUTF16("banana"),
1973 ASCIIToUTF16("Yellow"),
1974 ASCIIToUTF16("text"),
1975 20),
1976 fields2[1]);
1977 EXPECT_EQ(FormField(string16(),
1978 string16(),
1979 ASCIIToUTF16("Send"),
1980 ASCIIToUTF16("submit"),
1981 0),
1982 fields2[2]);
1983 }
1984
1985 TEST_F(FormManagerTest, ThreePartPhone) {
1986 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
1987 " Phone:"
1988 " <input type=\"text\" name=\"dayphone1\">"
1989 " -"
1990 " <input type=\"text\" name=\"dayphone2\">"
1991 " -"
1992 " <input type=\"text\" name=\"dayphone3\">"
1993 " ext.:"
1994 " <input type=\"text\" name=\"dayphone4\">"
1995 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">"
1996 "</FORM>");
1997
1998
1999 WebFrame* frame = GetMainFrame();
2000 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
2001
2002 WebVector<WebFormElement> forms;
2003 frame->forms(forms);
2004 ASSERT_EQ(1U, forms.size());
2005
2006 FormData form;
2007 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
2008 FormManager::REQUIRE_NONE,
2009 true,
2010 &form));
2011 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2012 EXPECT_EQ(GURL(frame->url()), form.origin);
2013 EXPECT_EQ(GURL("http://cnn.com"), form.action);
2014
2015 const std::vector<FormField>& fields = form.fields;
2016 ASSERT_EQ(5U, fields.size());
2017 EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
2018 ASCIIToUTF16("dayphone1"),
2019 string16(),
2020 ASCIIToUTF16("text"),
2021 20),
2022 fields[0]);
2023 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
2024 ASCIIToUTF16("dayphone2"),
2025 string16(),
2026 ASCIIToUTF16("text"),
2027 20),
2028 fields[1]);
2029 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
2030 ASCIIToUTF16("dayphone3"),
2031 string16(),
2032 ASCIIToUTF16("text"),
2033 20),
2034 fields[2]);
2035 EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
2036 ASCIIToUTF16("dayphone4"),
2037 string16(),
2038 ASCIIToUTF16("text"),
2039 20),
2040 fields[3]);
2041 EXPECT_EQ(FormField(string16(),
2042 ASCIIToUTF16("reply-send"),
2043 ASCIIToUTF16("Send"),
2044 ASCIIToUTF16("submit"),
2045 0),
2046 fields[4]);
2047 }
2048
2049
2050 TEST_F(FormManagerTest, SizeFields) {
2051 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
2052 " Phone:"
2053 " <input type=\"text\" size=\"3\" name=\"dayphone1\">"
2054 " -"
2055 " <input type=\"text\" size=\"3\" name=\"dayphone2\">"
2056 " -"
2057 " <input type=\"text\" size=\"4\" name=\"dayphone3\">"
2058 " ext.:"
2059 " <input type=\"text\" size=\"5\" name=\"dayphone4\">"
2060 " <input type=\"text\" name=\"default1\">"
2061 " <input type=\"text\" size=\"-1\" name=\"invalid1\">"
2062 " <input type=\"submit\" name=\"reply-send\" value=\"Send\">"
2063 "</FORM>");
2064
2065
2066 WebFrame* frame = GetMainFrame();
2067 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
2068
2069 WebVector<WebFormElement> forms;
2070 frame->forms(forms);
2071 ASSERT_EQ(1U, forms.size());
2072
2073 FormData form;
2074 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
2075 FormManager::REQUIRE_NONE,
2076 true,
2077 &form));
2078 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2079 EXPECT_EQ(GURL(frame->url()), form.origin);
2080 EXPECT_EQ(GURL("http://cnn.com"), form.action);
2081
2082 const std::vector<FormField>& fields = form.fields;
2083 ASSERT_EQ(7U, fields.size());
2084 EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
2085 ASCIIToUTF16("dayphone1"),
2086 string16(),
2087 ASCIIToUTF16("text"),
2088 3),
2089 fields[0]);
2090 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
2091 ASCIIToUTF16("dayphone2"),
2092 string16(),
2093 ASCIIToUTF16("text"),
2094 3),
2095 fields[1]);
2096 EXPECT_EQ(FormField(ASCIIToUTF16("-"),
2097 ASCIIToUTF16("dayphone3"),
2098 string16(),
2099 ASCIIToUTF16("text"),
2100 4),
2101 fields[2]);
2102 EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
2103 ASCIIToUTF16("dayphone4"),
2104 string16(),
2105 ASCIIToUTF16("text"),
2106 5),
2107 fields[3]);
2108 // When unspecified |size|, default is 20.
2109 EXPECT_EQ(FormField(string16(),
2110 ASCIIToUTF16("default1"),
2111 string16(),
2112 ASCIIToUTF16("text"),
2113 20),
2114 fields[4]);
2115 // When invalid |size| same value is returned.
2116 EXPECT_EQ(FormField(string16(),
2117 ASCIIToUTF16("invalid1"),
2118 string16(),
2119 ASCIIToUTF16("text"),
2120 -1),
2121 fields[5]);
2122 EXPECT_EQ(FormField(string16(),
2123 ASCIIToUTF16("reply-send"),
2124 ASCIIToUTF16("Send"),
2125 ASCIIToUTF16("submit"),
2126 0),
2127 fields[6]);
2128 }
2129
2130 // This test re-creates the experience of typing in a field then selecting a
2131 // profile from the AutoFill suggestions popup. The field that is being typed
2132 // into should be filled even though it's not technically empty.
2133 TEST_F(FormManagerTest, FillFormNonEmptyField) {
2134 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2135 " <INPUT type=\"text\" id=\"firstname\"/>"
2136 " <INPUT type=\"text\" id=\"lastname\"/>"
2137 " <INPUT type=\"submit\" value=\"Send\"/>"
2138 "</FORM>");
2139
2140 WebFrame* web_frame = GetMainFrame();
2141 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2142
2143 FormManager form_manager;
2144 form_manager.ExtractForms(web_frame);
2145
2146 // Verify that we have the form.
2147 std::vector<FormData> forms;
2148 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
2149 ASSERT_EQ(1U, forms.size());
2150
2151 // Get the input element we want to find.
2152 WebElement element = web_frame->document().getElementById("firstname");
2153 WebInputElement input_element = element.to<WebInputElement>();
2154
2155 // Simulate typing by modifying the field value.
2156 input_element.setValue(ASCIIToUTF16("Wy"));
2157
2158 // Find the form that contains the input element.
2159 FormData form;
2160 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
2161 input_element, FormManager::REQUIRE_NONE, &form));
2162 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2163 EXPECT_EQ(GURL(web_frame->url()), form.origin);
2164 EXPECT_EQ(GURL("http://buh.com"), form.action);
2165
2166 const std::vector<FormField>& fields = form.fields;
2167 ASSERT_EQ(3U, fields.size());
2168 EXPECT_EQ(FormField(string16(),
2169 ASCIIToUTF16("firstname"),
2170 string16(),
2171 ASCIIToUTF16("text"),
2172 20),
2173 fields[0]);
2174 EXPECT_EQ(FormField(string16(),
2175 ASCIIToUTF16("lastname"),
2176 string16(),
2177 ASCIIToUTF16("text"),
2178 20),
2179 fields[1]);
2180 EXPECT_EQ(FormField(string16(),
2181 string16(),
2182 ASCIIToUTF16("Send"),
2183 ASCIIToUTF16("submit"),
2184 0),
2185 fields[2]);
2186
2187 // Fill the form.
2188 form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
2189 form.fields[1].set_value(ASCIIToUTF16("Earp"));
2190 EXPECT_TRUE(form_manager.FillForm(form, input_element));
2191
2192 // Find the newly-filled form that contains the input element.
2193 FormData form2;
2194 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
2195 input_element, FormManager::REQUIRE_NONE, &form2));
2196 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2197 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
2198 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2199
2200 const std::vector<FormField>& fields2 = form2.fields;
2201 ASSERT_EQ(3U, fields2.size());
2202 EXPECT_EQ(FormField(string16(),
2203 ASCIIToUTF16("firstname"),
2204 ASCIIToUTF16("Wyatt"),
2205 ASCIIToUTF16("text"),
2206 20),
2207 fields2[0]);
2208 EXPECT_EQ(FormField(string16(),
2209 ASCIIToUTF16("lastname"),
2210 ASCIIToUTF16("Earp"),
2211 ASCIIToUTF16("text"),
2212 20),
2213 fields2[1]);
2214 EXPECT_EQ(FormField(string16(),
2215 string16(),
2216 ASCIIToUTF16("Send"),
2217 ASCIIToUTF16("submit"),
2218 0),
2219 fields2[2]);
2220 }
2221
2222 TEST_F(FormManagerTest, ClearFormWithNode) {
2223 LoadHTML(
2224 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2225 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
2226 " <INPUT type=\"text\" id=\"lastname\" value=\"Earp\"/>"
2227 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noAC\" value=\"one\"/>"
2228 " <INPUT type=\"text\" id=\"notenabled\" disabled=\"disabled\">"
2229 " <INPUT type=\"hidden\" id=\"notvisible\" value=\"apple\">"
2230 " <INPUT type=\"submit\" value=\"Send\"/>"
2231 "</FORM>");
2232
2233 WebFrame* web_frame = GetMainFrame();
2234 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2235
2236 FormManager form_manager;
2237 form_manager.ExtractForms(web_frame);
2238
2239 // Verify that we have the form.
2240 std::vector<FormData> forms;
2241 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
2242 ASSERT_EQ(1U, forms.size());
2243
2244 // Set the auto-filled attribute on the firstname element.
2245 WebInputElement firstname =
2246 web_frame->document().getElementById("firstname").to<WebInputElement>();
2247 firstname.setAutofilled(true);
2248
2249 // Set the value of the disabled attribute.
2250 WebInputElement notenabled =
2251 web_frame->document().getElementById("notenabled").to<WebInputElement>();
2252 notenabled.setValue(WebString::fromUTF8("no clear"));
2253
2254 // Clear the form.
2255 EXPECT_TRUE(form_manager.ClearFormWithNode(firstname));
2256
2257 // Verify that the auto-filled attribute has been turned off.
2258 EXPECT_FALSE(firstname.isAutofilled());
2259
2260 // Verify the form is cleared.
2261 FormData form2;
2262 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
2263 firstname, FormManager::REQUIRE_NONE, &form2));
2264 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2265 EXPECT_EQ(GURL(web_frame->url()), form2.origin);
2266 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2267
2268 const std::vector<FormField>& fields2 = form2.fields;
2269 ASSERT_EQ(6U, fields2.size());
2270 EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
2271 FormField(string16(),
2272 ASCIIToUTF16("firstname"),
2273 string16(),
2274 ASCIIToUTF16("text"),
2275 20)));
2276 EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
2277 FormField(string16(),
2278 ASCIIToUTF16("lastname"),
2279 string16(),
2280 ASCIIToUTF16("text"),
2281 20)));
2282 EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
2283 FormField(string16(),
2284 ASCIIToUTF16("noAC"),
2285 string16(),
2286 ASCIIToUTF16("text"),
2287 20)));
2288 EXPECT_TRUE(fields2[3].StrictlyEqualsHack(
2289 FormField(string16(),
2290 ASCIIToUTF16("notenabled"),
2291 ASCIIToUTF16("no clear"),
2292 ASCIIToUTF16("text"),
2293 20)));
2294 EXPECT_TRUE(fields2[4].StrictlyEqualsHack(
2295 FormField(string16(),
2296 ASCIIToUTF16("notvisible"),
2297 ASCIIToUTF16("apple"),
2298 ASCIIToUTF16("hidden"),
2299 0)));
2300 EXPECT_TRUE(fields2[5].StrictlyEqualsHack(
2301 FormField(string16(),
2302 string16(),
2303 string16(),
2304 ASCIIToUTF16("submit"),
2305 0)));
2306 }
2307
2308 TEST_F(FormManagerTest, ClearPreviewedFormWithNode) {
2309 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2310 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
2311 " <INPUT type=\"text\" id=\"lastname\"/>"
2312 " <INPUT type=\"text\" id=\"email\"/>"
2313 " <INPUT type=\"submit\" value=\"Send\"/>"
2314 "</FORM>");
2315
2316 WebFrame* web_frame = GetMainFrame();
2317 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2318
2319 FormManager form_manager;
2320 form_manager.ExtractForms(web_frame);
2321
2322 // Verify that we have the form.
2323 std::vector<FormData> forms;
2324 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
2325 ASSERT_EQ(1U, forms.size());
2326
2327 // Set the auto-filled attribute.
2328 WebInputElement firstname =
2329 web_frame->document().getElementById("firstname").to<WebInputElement>();
2330 firstname.setAutofilled(true);
2331 WebInputElement lastname =
2332 web_frame->document().getElementById("lastname").to<WebInputElement>();
2333 lastname.setAutofilled(true);
2334 WebInputElement email =
2335 web_frame->document().getElementById("email").to<WebInputElement>();
2336 email.setAutofilled(true);
2337
2338 // Set the suggested values on two of the elements.
2339 lastname.setSuggestedValue(ASCIIToUTF16("Earp"));
2340 email.setSuggestedValue(ASCIIToUTF16("wyatt@earp.com"));
2341
2342 // Clear the previewed fields.
2343 EXPECT_TRUE(form_manager.ClearPreviewedFormWithNode(firstname));
2344
2345 // Fields with non-empty values are not modified.
2346 EXPECT_EQ(ASCIIToUTF16("Wyatt"), firstname.value());
2347 EXPECT_TRUE(firstname.suggestedValue().isEmpty());
2348 EXPECT_TRUE(firstname.isAutofilled());
2349
2350 // Verify the previewed fields are cleared.
2351 EXPECT_TRUE(lastname.value().isEmpty());
2352 EXPECT_TRUE(lastname.suggestedValue().isEmpty());
2353 EXPECT_FALSE(lastname.isAutofilled());
2354 EXPECT_TRUE(email.value().isEmpty());
2355 EXPECT_TRUE(email.suggestedValue().isEmpty());
2356 EXPECT_FALSE(email.isAutofilled());
2357 }
2358
2359 TEST_F(FormManagerTest, FormWithNodeIsAutoFilled) {
2360 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2361 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
2362 " <INPUT type=\"text\" id=\"lastname\"/>"
2363 " <INPUT type=\"text\" id=\"email\"/>"
2364 " <INPUT type=\"submit\" value=\"Send\"/>"
2365 "</FORM>");
2366
2367 WebFrame* web_frame = GetMainFrame();
2368 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2369
2370 FormManager form_manager;
2371 form_manager.ExtractForms(web_frame);
2372
2373 // Verify that we have the form.
2374 std::vector<FormData> forms;
2375 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
2376 ASSERT_EQ(1U, forms.size());
2377
2378 WebInputElement firstname =
2379 web_frame->document().getElementById("firstname").to<WebInputElement>();
2380
2381 // Auto-filled attribute not set yet.
2382 EXPECT_FALSE(form_manager.FormWithNodeIsAutoFilled(firstname));
2383
2384 // Set the auto-filled attribute.
2385 firstname.setAutofilled(true);
2386
2387 EXPECT_TRUE(form_manager.FormWithNodeIsAutoFilled(firstname));
2388 }
2389
2390 TEST_F(FormManagerTest, LabelsHiddenFields) {
2391 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
2392 " <LABEL for=\"firstname\"> First name: </LABEL>"
2393 " <INPUT type=\"hidden\" id=\"firstname\" value=\"John\"/>"
2394 " <LABEL for=\"lastname\"> Last name: </LABEL>"
2395 " <INPUT type=\"hidden\" id=\"lastname\" value=\"Smith\"/>"
2396 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
2397 "</FORM>");
2398
2399 WebFrame* web_frame = GetMainFrame();
2400 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2401
2402 FormManager form_manager;
2403 form_manager.ExtractForms(web_frame);
2404
2405 std::vector<FormData> forms;
2406 form_manager.GetForms(FormManager::REQUIRE_NONE, &forms);
2407 ASSERT_EQ(1U, forms.size());
2408
2409 const FormData& form = forms[0];
2410 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2411 EXPECT_EQ(GURL(web_frame->url()), form.origin);
2412 EXPECT_EQ(GURL("http://cnn.com"), form.action);
2413
2414 const std::vector<FormField>& fields = form.fields;
2415 ASSERT_EQ(3U, fields.size());
2416 EXPECT_TRUE(fields[0].StrictlyEqualsHack(
2417 FormField(string16(),
2418 ASCIIToUTF16("firstname"),
2419 ASCIIToUTF16("John"),
2420 ASCIIToUTF16("hidden"),
2421 0)));
2422 EXPECT_TRUE(fields[1].StrictlyEqualsHack(
2423 FormField(string16(),
2424 ASCIIToUTF16("lastname"),
2425 ASCIIToUTF16("Smith"),
2426 ASCIIToUTF16("hidden"),
2427 0)));
2428 EXPECT_TRUE(fields[2].StrictlyEqualsHack(
2429 FormField(string16(),
2430 ASCIIToUTF16("reply-send"),
2431 string16(),
2432 ASCIIToUTF16("submit"),
2433 0)));
2434 }
2435
2436 TEST_F(FormManagerTest, LabelForElementHidden) {
2437 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
2438 " <LABEL for=\"firstname\"> First name: </LABEL>"
2439 " <INPUT type=\"hidden\" id=\"firstname\" value=\"John\"/>"
2440 " <LABEL for=\"lastname\"> Last name: </LABEL>"
2441 " <INPUT type=\"hidden\" id=\"lastname\" value=\"Smith\"/>"
2442 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
2443 "</FORM>");
2444
2445 WebFrame* web_frame = GetMainFrame();
2446 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
2447
2448 WebElement e = web_frame->document().getElementById("firstname");
2449 WebFormControlElement firstname = e.to<WebFormControlElement>();
2450
2451 // Hidden form control element should not have a label set.
2452 FormManager form_manager;
2453 EXPECT_EQ(string16(), form_manager.LabelForElement(firstname));
2454 }
2455
2456 } // namespace
OLDNEW
« no previous file with comments | « chrome/renderer/form_manager_browsertest.cc ('k') | chrome/renderer/pepper_devices_browsertest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698