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

Side by Side Diff: chrome/renderer/autofill/form_manager_browsertest.cc

Issue 7576001: Refactor webkit_glue::FormField to remove hacky methods (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Only FormField class refactoring Created 9 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
OLDNEW
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2011 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 <vector> 5 #include <vector>
6 6
7 #include "base/format_macros.h"
7 #include "base/string16.h" 8 #include "base/string16.h"
8 #include "base/string_util.h" 9 #include "base/string_util.h"
10 #include "base/stringprintf.h"
9 #include "base/utf_string_conversions.h" 11 #include "base/utf_string_conversions.h"
10 #include "chrome/renderer/autofill/form_manager.h" 12 #include "chrome/renderer/autofill/form_manager.h"
11 #include "chrome/test/base/render_view_test.h" 13 #include "chrome/test/base/render_view_test.h"
12 #include "testing/gtest/include/gtest/gtest.h" 14 #include "testing/gtest/include/gtest/gtest.h"
13 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h" 15 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
14 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h" 16 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
15 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement .h" 17 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormControlElement .h"
16 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h" 18 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFormElement.h"
17 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h" 19 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h"
18 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h" 20 #include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
(...skipping 12 matching lines...) Expand all
31 using WebKit::WebSelectElement; 33 using WebKit::WebSelectElement;
32 using WebKit::WebNode; 34 using WebKit::WebNode;
33 using WebKit::WebString; 35 using WebKit::WebString;
34 using WebKit::WebVector; 36 using WebKit::WebVector;
35 37
36 using autofill::FormManager; 38 using autofill::FormManager;
37 39
38 using webkit_glue::FormData; 40 using webkit_glue::FormData;
39 using webkit_glue::FormField; 41 using webkit_glue::FormField;
40 42
43 namespace {
44
45 void ExpectFieldEquals(const FormField& expected, const FormField& actual) {
46 EXPECT_EQ(expected.label, actual.label);
47 EXPECT_EQ(expected.name, actual.name);
48 EXPECT_EQ(expected.value, actual.value);
49 EXPECT_EQ(expected.form_control_type, actual.form_control_type);
50 EXPECT_EQ(expected.max_length, actual.max_length);
51 EXPECT_EQ(expected.is_autofilled, actual.is_autofilled);
52 }
53
54 } // namespace
55
41 class FormManagerTest : public RenderViewTest { 56 class FormManagerTest : public RenderViewTest {
42 public: 57 public:
43 FormManagerTest() : RenderViewTest() {} 58 FormManagerTest() : RenderViewTest() {}
44 virtual ~FormManagerTest() {} 59 virtual ~FormManagerTest() {}
45 60
46 void ExpectLabels(const char* html, 61 void ExpectLabels(const char* html,
47 const std::vector<string16>& labels, 62 const std::vector<string16>& labels,
48 const std::vector<string16>& names, 63 const std::vector<string16>& names,
49 const std::vector<string16>& values) { 64 const std::vector<string16>& values) {
50 std::vector<string16> control_types(labels.size(), ASCIIToUTF16("text")); 65 std::vector<string16> control_types(labels.size(), ASCIIToUTF16("text"));
(...skipping 22 matching lines...) Expand all
73 const FormData& form = forms[0]; 88 const FormData& form = forms[0];
74 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 89 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
75 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 90 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
76 EXPECT_EQ(GURL("http://cnn.com"), form.action); 91 EXPECT_EQ(GURL("http://cnn.com"), form.action);
77 92
78 const std::vector<FormField>& fields = form.fields; 93 const std::vector<FormField>& fields = form.fields;
79 ASSERT_EQ(labels.size(), fields.size()); 94 ASSERT_EQ(labels.size(), fields.size());
80 for (size_t i = 0; i < labels.size(); ++i) { 95 for (size_t i = 0; i < labels.size(); ++i) {
81 int max_length = control_types[i] == ASCIIToUTF16("text") ? 96 int max_length = control_types[i] == ASCIIToUTF16("text") ?
82 WebInputElement::defaultMaxLength() : 0; 97 WebInputElement::defaultMaxLength() : 0;
83 FormField expected = FormField(labels[i], 98 FormField expected;
84 names[i], 99 expected.label = labels[i];
85 values[i], 100 expected.name = names[i];
86 control_types[i], 101 expected.value = values[i];
87 max_length, 102 expected.form_control_type = control_types[i];
88 false); 103 expected.max_length = max_length;
89 EXPECT_TRUE(fields[i].StrictlyEqualsHack(expected)) 104 SCOPED_TRACE(StringPrintf("i: %" PRIuS, i));
90 << "Expected \"" << expected << "\", got \"" << fields[i] << "\""; 105 ExpectFieldEquals(expected, fields[i]);
91 } 106 }
92 } 107 }
93 108
94 void ExpectJohnSmithLabels(const char* html) { 109 void ExpectJohnSmithLabels(const char* html) {
95 std::vector<string16> labels, names, values; 110 std::vector<string16> labels, names, values;
96 111
97 labels.push_back(ASCIIToUTF16("First name:")); 112 labels.push_back(ASCIIToUTF16("First name:"));
98 names.push_back(ASCIIToUTF16("firstname")); 113 names.push_back(ASCIIToUTF16("firstname"));
99 values.push_back(ASCIIToUTF16("John")); 114 values.push_back(ASCIIToUTF16("John"));
100 115
(...skipping 18 matching lines...) Expand all
119 134
120 WebFrame* frame = GetMainFrame(); 135 WebFrame* frame = GetMainFrame();
121 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 136 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
122 137
123 WebElement web_element = frame->document().getElementById("element"); 138 WebElement web_element = frame->document().getElementById("element");
124 WebFormControlElement element = web_element.to<WebFormControlElement>(); 139 WebFormControlElement element = web_element.to<WebFormControlElement>();
125 FormField result1; 140 FormField result1;
126 FormManager::WebFormControlElementToFormField(element, 141 FormManager::WebFormControlElementToFormField(element,
127 FormManager::EXTRACT_NONE, 142 FormManager::EXTRACT_NONE,
128 &result1); 143 &result1);
129 EXPECT_TRUE(result1.StrictlyEqualsHack( 144
130 FormField(string16(), 145 FormField expected;
131 ASCIIToUTF16("element"), 146 expected.form_control_type = ASCIIToUTF16("text");
132 string16(), 147 expected.max_length = WebInputElement::defaultMaxLength();
133 ASCIIToUTF16("text"), 148
134 WebInputElement::defaultMaxLength(), 149 expected.name = ASCIIToUTF16("element");
135 false))); 150 expected.value = string16();
151 SCOPED_TRACE("");
dhollowa 2011/08/08 21:40:39 This is a touch magical. It is also repeated ever
Ilya Sherman 2011/08/09 00:13:43 Done.
152 ExpectFieldEquals(expected, result1);
153
136 FormField result2; 154 FormField result2;
137 FormManager::WebFormControlElementToFormField(element, 155 FormManager::WebFormControlElementToFormField(element,
138 FormManager::EXTRACT_VALUE, 156 FormManager::EXTRACT_VALUE,
139 &result2); 157 &result2);
140 EXPECT_TRUE(result2.StrictlyEqualsHack( 158
141 FormField(string16(), 159 expected.name = ASCIIToUTF16("element");
142 ASCIIToUTF16("element"), 160 expected.value = ASCIIToUTF16("value");
143 ASCIIToUTF16("value"), 161 SCOPED_TRACE("");
144 ASCIIToUTF16("text"), 162 ExpectFieldEquals(expected, result2);
145 WebInputElement::defaultMaxLength(),
146 false)));
147 } 163 }
148 164
149 // We should be able to extract a text field with autocomplete="off". 165 // We should be able to extract a text field with autocomplete="off".
150 TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutocompleteOff) { 166 TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutocompleteOff) {
151 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"" 167 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
152 " autocomplete=\"off\"/>"); 168 " autocomplete=\"off\"/>");
153 169
154 WebFrame* frame = GetMainFrame(); 170 WebFrame* frame = GetMainFrame();
155 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 171 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
156 172
157 WebElement web_element = frame->document().getElementById("element"); 173 WebElement web_element = frame->document().getElementById("element");
158 WebFormControlElement element = web_element.to<WebFormControlElement>(); 174 WebFormControlElement element = web_element.to<WebFormControlElement>();
159 FormField result; 175 FormField result;
160 FormManager::WebFormControlElementToFormField(element, 176 FormManager::WebFormControlElementToFormField(element,
161 FormManager::EXTRACT_VALUE, 177 FormManager::EXTRACT_VALUE,
162 &result); 178 &result);
163 EXPECT_TRUE(result.StrictlyEqualsHack( 179
164 FormField(string16(), 180 FormField expected;
165 ASCIIToUTF16("element"), 181 expected.name = ASCIIToUTF16("element");
166 ASCIIToUTF16("value"), 182 expected.value = ASCIIToUTF16("value");
167 ASCIIToUTF16("text"), 183 expected.form_control_type = ASCIIToUTF16("text");
168 WebInputElement::defaultMaxLength(), 184 expected.max_length = WebInputElement::defaultMaxLength();
169 false))); 185 SCOPED_TRACE("");
186 ExpectFieldEquals(expected, result);
170 } 187 }
171 188
172 // We should be able to extract a text field with maxlength specified. 189 // We should be able to extract a text field with maxlength specified.
173 TEST_F(FormManagerTest, WebFormControlElementToFormFieldMaxLength) { 190 TEST_F(FormManagerTest, WebFormControlElementToFormFieldMaxLength) {
174 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"" 191 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
175 " maxlength=\"5\"/>"); 192 " maxlength=\"5\"/>");
176 193
177 WebFrame* frame = GetMainFrame(); 194 WebFrame* frame = GetMainFrame();
178 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 195 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
179 196
180 WebElement web_element = frame->document().getElementById("element"); 197 WebElement web_element = frame->document().getElementById("element");
181 WebFormControlElement element = web_element.to<WebFormControlElement>(); 198 WebFormControlElement element = web_element.to<WebFormControlElement>();
182 FormField result; 199 FormField result;
183 FormManager::WebFormControlElementToFormField(element, 200 FormManager::WebFormControlElementToFormField(element,
184 FormManager::EXTRACT_VALUE, 201 FormManager::EXTRACT_VALUE,
185 &result); 202 &result);
186 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 203
187 ASCIIToUTF16("element"), 204 FormField expected;
188 ASCIIToUTF16("value"), 205 expected.name = ASCIIToUTF16("element");
189 ASCIIToUTF16("text"), 206 expected.value = ASCIIToUTF16("value");
190 5, 207 expected.form_control_type = ASCIIToUTF16("text");
191 false))); 208 expected.max_length = 5;
209 SCOPED_TRACE("");
210 ExpectFieldEquals(expected, result);
192 } 211 }
193 212
194 // We should be able to extract a text field that has been autofilled. 213 // We should be able to extract a text field that has been autofilled.
195 TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutofilled) { 214 TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutofilled) {
196 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>"); 215 LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>");
197 216
198 WebFrame* frame = GetMainFrame(); 217 WebFrame* frame = GetMainFrame();
199 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 218 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
200 219
201 WebElement web_element = frame->document().getElementById("element"); 220 WebElement web_element = frame->document().getElementById("element");
202 WebInputElement element = web_element.to<WebInputElement>(); 221 WebInputElement element = web_element.to<WebInputElement>();
203 element.setAutofilled(true); 222 element.setAutofilled(true);
204 FormField result; 223 FormField result;
205 FormManager::WebFormControlElementToFormField(element, 224 FormManager::WebFormControlElementToFormField(element,
206 FormManager::EXTRACT_VALUE, 225 FormManager::EXTRACT_VALUE,
207 &result); 226 &result);
208 EXPECT_TRUE(result.StrictlyEqualsHack( 227
209 FormField(string16(), 228 FormField expected;
210 ASCIIToUTF16("element"), 229 expected.name = ASCIIToUTF16("element");
211 ASCIIToUTF16("value"), 230 expected.value = ASCIIToUTF16("value");
212 ASCIIToUTF16("text"), 231 expected.form_control_type = ASCIIToUTF16("text");
213 WebInputElement::defaultMaxLength(), 232 expected.max_length = WebInputElement::defaultMaxLength();
214 true))); 233 expected.is_autofilled = true;
234 SCOPED_TRACE("");
235 ExpectFieldEquals(expected, result);
215 } 236 }
216 237
217 // We should be able to extract a <select> field. 238 // We should be able to extract a <select> field.
218 TEST_F(FormManagerTest, WebFormControlElementToFormFieldSelect) { 239 TEST_F(FormManagerTest, WebFormControlElementToFormFieldSelect) {
219 LoadHTML("<SELECT id=\"element\"/>" 240 LoadHTML("<SELECT id=\"element\"/>"
220 " <OPTION value=\"CA\">California</OPTION>" 241 " <OPTION value=\"CA\">California</OPTION>"
221 " <OPTION value=\"TX\">Texas</OPTION>" 242 " <OPTION value=\"TX\">Texas</OPTION>"
222 "</SELECT>"); 243 "</SELECT>");
223 244
224 WebFrame* frame = GetMainFrame(); 245 WebFrame* frame = GetMainFrame();
225 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 246 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
226 247
227 WebElement web_element = frame->document().getElementById("element"); 248 WebElement web_element = frame->document().getElementById("element");
228 WebFormControlElement element = web_element.to<WebFormControlElement>(); 249 WebFormControlElement element = web_element.to<WebFormControlElement>();
229 FormField result1; 250 FormField result1;
230 FormManager::WebFormControlElementToFormField(element, 251 FormManager::WebFormControlElementToFormField(element,
231 FormManager::EXTRACT_VALUE, 252 FormManager::EXTRACT_VALUE,
232 &result1); 253 &result1);
233 EXPECT_TRUE(result1.StrictlyEqualsHack(FormField(string16(), 254
234 ASCIIToUTF16("element"), 255 FormField expected;
235 ASCIIToUTF16("CA"), 256 expected.name = ASCIIToUTF16("element");
236 ASCIIToUTF16("select-one"), 257 expected.max_length = 0;
237 0, 258 expected.form_control_type = ASCIIToUTF16("select-one");
238 false))); 259
260 expected.value = ASCIIToUTF16("CA");
261 SCOPED_TRACE("");
262 ExpectFieldEquals(expected, result1);
263
239 FormField result2; 264 FormField result2;
240 FormManager::WebFormControlElementToFormField( 265 FormManager::WebFormControlElementToFormField(
241 element, 266 element,
242 static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE | 267 static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE |
243 FormManager::EXTRACT_OPTION_TEXT), 268 FormManager::EXTRACT_OPTION_TEXT),
244 &result2); 269 &result2);
245 EXPECT_TRUE(result2.StrictlyEqualsHack(FormField(string16(), 270 expected.value = ASCIIToUTF16("California");
246 ASCIIToUTF16("element"), 271 SCOPED_TRACE("");
247 ASCIIToUTF16("California"), 272 ExpectFieldEquals(expected, result2);
248 ASCIIToUTF16("select-one"), 273
249 0,
250 false)));
251 FormField result3; 274 FormField result3;
252 FormManager::WebFormControlElementToFormField(element, 275 FormManager::WebFormControlElementToFormField(element,
253 FormManager::EXTRACT_OPTIONS, 276 FormManager::EXTRACT_OPTIONS,
254 &result3); 277 &result3);
255 EXPECT_TRUE(result3.StrictlyEqualsHack(FormField(string16(), 278 expected.value = string16();
256 ASCIIToUTF16("element"), 279 SCOPED_TRACE("");
257 string16(), 280 ExpectFieldEquals(expected, result3);
258 ASCIIToUTF16("select-one"), 281
259 0,
260 false)));
261 ASSERT_EQ(2U, result3.option_values.size()); 282 ASSERT_EQ(2U, result3.option_values.size());
262 ASSERT_EQ(2U, result3.option_contents.size()); 283 ASSERT_EQ(2U, result3.option_contents.size());
263 EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]); 284 EXPECT_EQ(ASCIIToUTF16("CA"), result3.option_values[0]);
264 EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]); 285 EXPECT_EQ(ASCIIToUTF16("California"), result3.option_contents[0]);
265 EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]); 286 EXPECT_EQ(ASCIIToUTF16("TX"), result3.option_values[1]);
266 EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]); 287 EXPECT_EQ(ASCIIToUTF16("Texas"), result3.option_contents[1]);
267 } 288 }
268 289
269 // We should be not extract the value for non-text and non-select fields. 290 // We should not extract the value for non-text and non-select fields.
270 TEST_F(FormManagerTest, WebFormControlElementToFormFieldInvalidType) { 291 TEST_F(FormManagerTest, WebFormControlElementToFormFieldInvalidType) {
271 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 292 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
272 " <INPUT type=\"hidden\" id=\"hidden\" value=\"apple\"/>" 293 " <INPUT type=\"hidden\" id=\"hidden\" value=\"apple\"/>"
273 " <INPUT type=\"password\" id=\"password\" value=\"secret\"/>" 294 " <INPUT type=\"password\" id=\"password\" value=\"secret\"/>"
274 " <INPUT type=\"checkbox\" id=\"checkbox\" value=\"mail\"/>" 295 " <INPUT type=\"checkbox\" id=\"checkbox\" value=\"mail\"/>"
275 " <INPUT type=\"radio\" id=\"radio\" value=\"male\"/>" 296 " <INPUT type=\"radio\" id=\"radio\" value=\"male\"/>"
276 " <INPUT type=\"submit\" id=\"submit\" value=\"Send\"/>" 297 " <INPUT type=\"submit\" id=\"submit\" value=\"Send\"/>"
277 "</FORM>"); 298 "</FORM>");
278 299
279 WebFrame* frame = GetMainFrame(); 300 WebFrame* frame = GetMainFrame();
280 ASSERT_NE(static_cast<WebFrame*>(NULL), frame); 301 ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
281 302
282 WebElement web_element = frame->document().getElementById("hidden"); 303 WebElement web_element = frame->document().getElementById("hidden");
283 WebFormControlElement element = web_element.to<WebFormControlElement>(); 304 WebFormControlElement element = web_element.to<WebFormControlElement>();
284 FormField result; 305 FormField result;
285 FormManager::WebFormControlElementToFormField(element, 306 FormManager::WebFormControlElementToFormField(element,
286 FormManager::EXTRACT_VALUE, 307 FormManager::EXTRACT_VALUE,
287 &result); 308 &result);
288 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 309
289 ASCIIToUTF16("hidden"), 310 FormField expected;
290 string16(), 311 expected.max_length = 0;
291 ASCIIToUTF16("hidden"), 312
292 0, 313 expected.name = ASCIIToUTF16("hidden");
293 false))); 314 expected.form_control_type = ASCIIToUTF16("hidden");
315 SCOPED_TRACE("");
316 ExpectFieldEquals(expected, result);
294 317
295 web_element = frame->document().getElementById("password"); 318 web_element = frame->document().getElementById("password");
296 element = web_element.to<WebFormControlElement>(); 319 element = web_element.to<WebFormControlElement>();
297 FormManager::WebFormControlElementToFormField(element, 320 FormManager::WebFormControlElementToFormField(element,
298 FormManager::EXTRACT_VALUE, 321 FormManager::EXTRACT_VALUE,
299 &result); 322 &result);
300 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 323 expected.name = ASCIIToUTF16("password");
301 ASCIIToUTF16("password"), 324 expected.form_control_type = ASCIIToUTF16("password");
302 string16(), 325 SCOPED_TRACE("");
303 ASCIIToUTF16("password"), 326 ExpectFieldEquals(expected, result);
304 0,
305 false)));
306 327
307 web_element = frame->document().getElementById("checkbox"); 328 web_element = frame->document().getElementById("checkbox");
308 element = web_element.to<WebFormControlElement>(); 329 element = web_element.to<WebFormControlElement>();
309 FormManager::WebFormControlElementToFormField(element, 330 FormManager::WebFormControlElementToFormField(element,
310 FormManager::EXTRACT_VALUE, 331 FormManager::EXTRACT_VALUE,
311 &result); 332 &result);
312 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 333 expected.name = ASCIIToUTF16("checkbox");
313 ASCIIToUTF16("checkbox"), 334 expected.form_control_type = ASCIIToUTF16("checkbox");
314 string16(), 335 SCOPED_TRACE("");
315 ASCIIToUTF16("checkbox"), 336 ExpectFieldEquals(expected, result);
316 0,
317 false)));
318 337
319 web_element = frame->document().getElementById("radio"); 338 web_element = frame->document().getElementById("radio");
320 element = web_element.to<WebFormControlElement>(); 339 element = web_element.to<WebFormControlElement>();
321 FormManager::WebFormControlElementToFormField(element, 340 FormManager::WebFormControlElementToFormField(element,
322 FormManager::EXTRACT_VALUE, 341 FormManager::EXTRACT_VALUE,
323 &result); 342 &result);
324 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 343 expected.name = ASCIIToUTF16("radio");
325 ASCIIToUTF16("radio"), 344 expected.form_control_type = ASCIIToUTF16("radio");
326 string16(), 345 SCOPED_TRACE("");
327 ASCIIToUTF16("radio"), 346 ExpectFieldEquals(expected, result);
328 0, 347
329 false)));
330 348
331 web_element = frame->document().getElementById("submit"); 349 web_element = frame->document().getElementById("submit");
332 element = web_element.to<WebFormControlElement>(); 350 element = web_element.to<WebFormControlElement>();
333 FormManager::WebFormControlElementToFormField(element, 351 FormManager::WebFormControlElementToFormField(element,
334 FormManager::EXTRACT_VALUE, 352 FormManager::EXTRACT_VALUE,
335 &result); 353 &result);
336 EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(), 354 expected.name = ASCIIToUTF16("submit");
337 ASCIIToUTF16("submit"), 355 expected.form_control_type = ASCIIToUTF16("submit");
338 string16(), 356 SCOPED_TRACE("");
339 ASCIIToUTF16("submit"), 357 ExpectFieldEquals(expected, result);
340 0,
341 false)));
342 } 358 }
343 359
344 TEST_F(FormManagerTest, WebFormElementToFormData) { 360 TEST_F(FormManagerTest, WebFormElementToFormData) {
345 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 361 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
346 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 362 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
347 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 363 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
348 " <SELECT id=\"state\"/>" 364 " <SELECT id=\"state\"/>"
349 " <OPTION value=\"CA\">California</OPTION>" 365 " <OPTION value=\"CA\">California</OPTION>"
350 " <OPTION value=\"TX\">Texas</OPTION>" 366 " <OPTION value=\"TX\">Texas</OPTION>"
351 " </SELECT>" 367 " </SELECT>"
(...skipping 14 matching lines...) Expand all
366 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0], 382 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
367 FormManager::REQUIRE_NONE, 383 FormManager::REQUIRE_NONE,
368 FormManager::EXTRACT_VALUE, 384 FormManager::EXTRACT_VALUE,
369 &form)); 385 &form));
370 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 386 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
371 EXPECT_EQ(GURL(frame->document().url()), form.origin); 387 EXPECT_EQ(GURL(frame->document().url()), form.origin);
372 EXPECT_EQ(GURL("http://cnn.com"), form.action); 388 EXPECT_EQ(GURL("http://cnn.com"), form.action);
373 389
374 const std::vector<FormField>& fields = form.fields; 390 const std::vector<FormField>& fields = form.fields;
375 ASSERT_EQ(3U, fields.size()); 391 ASSERT_EQ(3U, fields.size());
376 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 392
377 FormField(string16(), 393 FormField expected;
378 ASCIIToUTF16("firstname"), 394 expected.name = ASCIIToUTF16("firstname");
379 ASCIIToUTF16("John"), 395 expected.value = ASCIIToUTF16("John");
380 ASCIIToUTF16("text"), 396 expected.form_control_type = ASCIIToUTF16("text");
381 WebInputElement::defaultMaxLength(), 397 expected.max_length = WebInputElement::defaultMaxLength();
382 false))); 398 SCOPED_TRACE("");
383 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 399 ExpectFieldEquals(expected, fields[0]);
384 FormField(string16(), 400
385 ASCIIToUTF16("lastname"), 401 expected.name = ASCIIToUTF16("lastname");
386 ASCIIToUTF16("Smith"), 402 expected.value = ASCIIToUTF16("Smith");
387 ASCIIToUTF16("text"), 403 expected.form_control_type = ASCIIToUTF16("text");
388 WebInputElement::defaultMaxLength(), 404 expected.max_length = WebInputElement::defaultMaxLength();
389 false))); 405 SCOPED_TRACE("");
390 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 406 ExpectFieldEquals(expected, fields[1]);
391 FormField(string16(), 407
392 ASCIIToUTF16("state"), 408 expected.name = ASCIIToUTF16("state");
393 ASCIIToUTF16("CA"), 409 expected.value = ASCIIToUTF16("CA");
394 ASCIIToUTF16("select-one"), 410 expected.form_control_type = ASCIIToUTF16("select-one");
395 0, 411 expected.max_length = 0;
396 false))); 412 SCOPED_TRACE("");
413 ExpectFieldEquals(expected, fields[2]);
397 } 414 }
398 415
399 TEST_F(FormManagerTest, ExtractForms) { 416 TEST_F(FormManagerTest, ExtractForms) {
400 ExpectJohnSmithLabels( 417 ExpectJohnSmithLabels(
401 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 418 "<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
402 " First name: <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 419 " First name: <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
403 " Last name: <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 420 " Last name: <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
404 " Email: <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>" 421 " Email: <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
405 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 422 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
406 "</FORM>"); 423 "</FORM>");
(...skipping 22 matching lines...) Expand all
429 ASSERT_EQ(2U, forms.size()); 446 ASSERT_EQ(2U, forms.size());
430 447
431 // First form. 448 // First form.
432 const FormData& form = forms[0]; 449 const FormData& form = forms[0];
433 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 450 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
434 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 451 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
435 EXPECT_EQ(GURL("http://cnn.com"), form.action); 452 EXPECT_EQ(GURL("http://cnn.com"), form.action);
436 453
437 const std::vector<FormField>& fields = form.fields; 454 const std::vector<FormField>& fields = form.fields;
438 ASSERT_EQ(3U, fields.size()); 455 ASSERT_EQ(3U, fields.size());
439 EXPECT_EQ(FormField(string16(), 456
440 ASCIIToUTF16("firstname"), 457 FormField expected;
441 ASCIIToUTF16("John"), 458 expected.form_control_type = ASCIIToUTF16("text");
442 ASCIIToUTF16("text"), 459 expected.max_length = WebInputElement::defaultMaxLength();
443 WebInputElement::defaultMaxLength(), 460
444 false), 461 expected.name = ASCIIToUTF16("firstname");
445 fields[0]); 462 expected.value = ASCIIToUTF16("John");
446 EXPECT_EQ(FormField(string16(), 463 SCOPED_TRACE("");
447 ASCIIToUTF16("lastname"), 464 ExpectFieldEquals(expected, fields[0]);
448 ASCIIToUTF16("Smith"), 465
449 ASCIIToUTF16("text"), 466 expected.name = ASCIIToUTF16("lastname");
450 WebInputElement::defaultMaxLength(), 467 expected.value = ASCIIToUTF16("Smith");
451 false), 468 SCOPED_TRACE("");
452 fields[1]); 469 ExpectFieldEquals(expected, fields[1]);
453 EXPECT_EQ(FormField(string16(), 470
454 ASCIIToUTF16("email"), 471 expected.name = ASCIIToUTF16("email");
455 ASCIIToUTF16("john@example.com"), 472 expected.value = ASCIIToUTF16("john@example.com");
456 ASCIIToUTF16("text"), 473 SCOPED_TRACE("");
457 WebInputElement::defaultMaxLength(), 474 ExpectFieldEquals(expected, fields[2]);
458 false),
459 fields[2]);
460 475
461 // Second form. 476 // Second form.
462 const FormData& form2 = forms[1]; 477 const FormData& form2 = forms[1];
463 EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name); 478 EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name);
464 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 479 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
465 EXPECT_EQ(GURL("http://zoo.com"), form2.action); 480 EXPECT_EQ(GURL("http://zoo.com"), form2.action);
466 481
467 const std::vector<FormField>& fields2 = form2.fields; 482 const std::vector<FormField>& fields2 = form2.fields;
468 ASSERT_EQ(3U, fields2.size()); 483 ASSERT_EQ(3U, fields2.size());
469 EXPECT_EQ(FormField(string16(), 484
470 ASCIIToUTF16("firstname"), 485 expected.name = ASCIIToUTF16("firstname");
471 ASCIIToUTF16("Jack"), 486 expected.value = ASCIIToUTF16("Jack");
472 ASCIIToUTF16("text"), 487 SCOPED_TRACE("");
473 WebInputElement::defaultMaxLength(), 488 ExpectFieldEquals(expected, fields2[0]);
474 false), 489
475 fields2[0]); 490 expected.name = ASCIIToUTF16("lastname");
476 EXPECT_EQ(FormField(string16(), 491 expected.value = ASCIIToUTF16("Adams");
477 ASCIIToUTF16("lastname"), 492 SCOPED_TRACE("");
478 ASCIIToUTF16("Adams"), 493 ExpectFieldEquals(expected, fields2[1]);
479 ASCIIToUTF16("text"), 494
480 WebInputElement::defaultMaxLength(), 495 expected.name = ASCIIToUTF16("email");
481 false), 496 expected.value = ASCIIToUTF16("jack@example.com");
482 fields2[1]); 497 SCOPED_TRACE("");
483 EXPECT_EQ(FormField(string16(), 498 ExpectFieldEquals(expected, fields2[2]);
484 ASCIIToUTF16("email"),
485 ASCIIToUTF16("jack@example.com"),
486 ASCIIToUTF16("text"),
487 WebInputElement::defaultMaxLength(),
488 false),
489 fields[2]);
490 } 499 }
491 500
492 // We should not extract a form if it has too few fillable fields. 501 // We should not extract a form if it has too few fillable fields.
493 TEST_F(FormManagerTest, ExtractFormsTooFewFields) { 502 TEST_F(FormManagerTest, ExtractFormsTooFewFields) {
494 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 503 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
495 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 504 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
496 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 505 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
497 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 506 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
498 "</FORM>"); 507 "</FORM>");
499 508
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
548 WebFrame* web_frame = GetMainFrame(); 557 WebFrame* web_frame = GetMainFrame();
549 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 558 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
550 559
551 WebVector<WebFormElement> web_forms; 560 WebVector<WebFormElement> web_forms;
552 web_frame->document().forms(web_forms); 561 web_frame->document().forms(web_forms);
553 ASSERT_EQ(1U, web_forms.size()); 562 ASSERT_EQ(1U, web_forms.size());
554 WebFormElement web_form = web_forms[0]; 563 WebFormElement web_form = web_forms[0];
555 564
556 FormData form; 565 FormData form;
557 EXPECT_TRUE(FormManager::WebFormElementToFormData( 566 EXPECT_TRUE(FormManager::WebFormElementToFormData(
558 web_form, FormManager::REQUIRE_AUTOCOMPLETE, FormManager::EXTRACT_NONE, 567 web_form, FormManager::REQUIRE_AUTOCOMPLETE, FormManager::EXTRACT_VALUE,
559 &form)); 568 &form));
560 569
561 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 570 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
562 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 571 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
563 EXPECT_EQ(GURL("http://abc.com"), form.action); 572 EXPECT_EQ(GURL("http://abc.com"), form.action);
564 573
565 const std::vector<FormField>& fields = form.fields; 574 const std::vector<FormField>& fields = form.fields;
566 ASSERT_EQ(3U, fields.size()); 575 ASSERT_EQ(3U, fields.size());
567 EXPECT_EQ(FormField(string16(), 576
568 ASCIIToUTF16("middlename"), 577 FormField expected;
569 ASCIIToUTF16("Jack"), 578 expected.form_control_type = ASCIIToUTF16("text");
570 ASCIIToUTF16("text"), 579 expected.max_length = WebInputElement::defaultMaxLength();
571 WebInputElement::defaultMaxLength(), 580
572 false), 581 expected.name = ASCIIToUTF16("middlename");
573 fields[0]); 582 expected.value = ASCIIToUTF16("Jack");
574 EXPECT_EQ(FormField(string16(), 583 SCOPED_TRACE("");
575 ASCIIToUTF16("lastname"), 584 ExpectFieldEquals(expected, fields[0]);
576 ASCIIToUTF16("Smith"), 585
577 ASCIIToUTF16("text"), 586 expected.name = ASCIIToUTF16("lastname");
578 WebInputElement::defaultMaxLength(), 587 expected.value = ASCIIToUTF16("Smith");
579 false), 588 SCOPED_TRACE("");
580 fields[1]); 589 ExpectFieldEquals(expected, fields[1]);
581 EXPECT_EQ(FormField(string16(), 590
582 ASCIIToUTF16("email"), 591 expected.name = ASCIIToUTF16("email");
583 ASCIIToUTF16("john@example.com"), 592 expected.value = ASCIIToUTF16("john@example.com");
584 ASCIIToUTF16("text"), 593 SCOPED_TRACE("");
585 WebInputElement::defaultMaxLength(), 594 ExpectFieldEquals(expected, fields[2]);
586 false),
587 fields[2]);
588 } 595 }
589 } 596 }
590 597
591 TEST_F(FormManagerTest, WebFormElementToFormDataEnabled) { 598 TEST_F(FormManagerTest, WebFormElementToFormDataEnabled) {
592 // The firstname element is not enabled due to disabled being set. 599 // The firstname element is not enabled due to disabled being set.
593 LoadHTML("<FORM name=\"TestForm\" action=\"http://xyz.com\" method=\"post\">" 600 LoadHTML("<FORM name=\"TestForm\" action=\"http://xyz.com\" method=\"post\">"
594 " <INPUT disabled type=\"text\" id=\"firstname\" value=\"John\"/>" 601 " <INPUT disabled type=\"text\" id=\"firstname\" value=\"John\"/>"
595 " <INPUT type=\"text\" id=\"middlename\" value=\"Jack\"/>" 602 " <INPUT type=\"text\" id=\"middlename\" value=\"Jack\"/>"
596 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 603 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
597 " <INPUT type=\"text\" id=\"email\" value=\"jack@example.com\"/>" 604 " <INPUT type=\"text\" id=\"email\" value=\"jack@example.com\"/>"
598 " <INPUT type=\"submit\" name=\"submit\" value=\"Send\"/>" 605 " <INPUT type=\"submit\" name=\"submit\" value=\"Send\"/>"
599 "</FORM>"); 606 "</FORM>");
600 607
601 WebFrame* web_frame = GetMainFrame(); 608 WebFrame* web_frame = GetMainFrame();
602 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame); 609 ASSERT_NE(static_cast<WebFrame*>(NULL), web_frame);
603 610
604 WebVector<WebFormElement> web_forms; 611 WebVector<WebFormElement> web_forms;
605 web_frame->document().forms(web_forms); 612 web_frame->document().forms(web_forms);
606 ASSERT_EQ(1U, web_forms.size()); 613 ASSERT_EQ(1U, web_forms.size());
607 WebFormElement web_form = web_forms[0]; 614 WebFormElement web_form = web_forms[0];
608 615
609 FormData form; 616 FormData form;
610 EXPECT_TRUE(FormManager::WebFormElementToFormData( 617 EXPECT_TRUE(FormManager::WebFormElementToFormData(
611 web_form, FormManager::REQUIRE_ENABLED, FormManager::EXTRACT_NONE, 618 web_form, FormManager::REQUIRE_ENABLED, FormManager::EXTRACT_VALUE,
612 &form)); 619 &form));
613 620
614 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 621 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
615 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 622 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
616 EXPECT_EQ(GURL("http://xyz.com"), form.action); 623 EXPECT_EQ(GURL("http://xyz.com"), form.action);
617 624
618 const std::vector<FormField>& fields = form.fields; 625 const std::vector<FormField>& fields = form.fields;
619 ASSERT_EQ(3U, fields.size()); 626 ASSERT_EQ(3U, fields.size());
620 EXPECT_EQ(FormField(string16(), 627
621 ASCIIToUTF16("middlename"), 628 FormField expected;
622 ASCIIToUTF16("Jack"), 629 expected.form_control_type = ASCIIToUTF16("text");
623 ASCIIToUTF16("text"), 630 expected.max_length = WebInputElement::defaultMaxLength();
624 WebInputElement::defaultMaxLength(), 631
625 false), 632 expected.name = ASCIIToUTF16("middlename");
626 fields[0]); 633 expected.value = ASCIIToUTF16("Jack");
627 EXPECT_EQ(FormField(string16(), 634 SCOPED_TRACE("");
628 ASCIIToUTF16("lastname"), 635 ExpectFieldEquals(expected, fields[0]);
629 ASCIIToUTF16("Smith"), 636
630 ASCIIToUTF16("text"), 637 expected.name = ASCIIToUTF16("lastname");
631 WebInputElement::defaultMaxLength(), 638 expected.value = ASCIIToUTF16("Smith");
632 false), 639 SCOPED_TRACE("");
633 fields[1]); 640 ExpectFieldEquals(expected, fields[1]);
634 EXPECT_EQ(FormField(string16(), 641
635 ASCIIToUTF16("email"), 642 expected.name = ASCIIToUTF16("email");
636 ASCIIToUTF16("jack@example.com"), 643 expected.value = ASCIIToUTF16("jack@example.com");
637 ASCIIToUTF16("text"), 644 SCOPED_TRACE("");
638 WebInputElement::defaultMaxLength(), 645 ExpectFieldEquals(expected, fields[2]);
639 false),
640 fields[2]);
641 } 646 }
642 647
643 TEST_F(FormManagerTest, FindForm) { 648 TEST_F(FormManagerTest, FindForm) {
644 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 649 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
645 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>" 650 " <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
646 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>" 651 " <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
647 " <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>" 652 " <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
648 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 653 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
649 "</FORM>"); 654 "</FORM>");
650 655
(...skipping 12 matching lines...) Expand all
663 // Find the form and verify it's the correct form. 668 // Find the form and verify it's the correct form.
664 FormData form; 669 FormData form;
665 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 670 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
666 &form)); 671 &form));
667 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 672 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
668 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 673 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
669 EXPECT_EQ(GURL("http://buh.com"), form.action); 674 EXPECT_EQ(GURL("http://buh.com"), form.action);
670 675
671 const std::vector<FormField>& fields = form.fields; 676 const std::vector<FormField>& fields = form.fields;
672 ASSERT_EQ(3U, fields.size()); 677 ASSERT_EQ(3U, fields.size());
673 EXPECT_EQ(FormField(string16(), 678
674 ASCIIToUTF16("firstname"), 679 FormField expected;
675 ASCIIToUTF16("John"), 680 expected.form_control_type = ASCIIToUTF16("text");
676 ASCIIToUTF16("text"), 681 expected.max_length = WebInputElement::defaultMaxLength();
677 WebInputElement::defaultMaxLength(), 682
678 false), 683 expected.name = ASCIIToUTF16("firstname");
679 fields[0]); 684 expected.value = ASCIIToUTF16("John");
680 EXPECT_EQ(FormField(string16(), 685 SCOPED_TRACE("");
681 ASCIIToUTF16("lastname"), 686 ExpectFieldEquals(expected, fields[0]);
682 ASCIIToUTF16("Smith"), 687
683 ASCIIToUTF16("text"), 688 expected.name = ASCIIToUTF16("lastname");
684 WebInputElement::defaultMaxLength(), 689 expected.value = ASCIIToUTF16("Smith");
685 false), 690 SCOPED_TRACE("");
686 fields[1]); 691 ExpectFieldEquals(expected, fields[1]);
687 EXPECT_EQ(FormField(string16(), 692
688 ASCIIToUTF16("email"), 693 expected.name = ASCIIToUTF16("email");
689 ASCIIToUTF16("john@example.com"), 694 expected.value = ASCIIToUTF16("john@example.com");
690 ASCIIToUTF16("text"), 695 SCOPED_TRACE("");
691 WebInputElement::defaultMaxLength(), 696 ExpectFieldEquals(expected, fields[2]);
692 false),
693 fields[2]);
694 } 697 }
695 698
696 TEST_F(FormManagerTest, FillForm) { 699 TEST_F(FormManagerTest, FillForm) {
697 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 700 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
698 " <INPUT type=\"text\" id=\"firstname\"/>" 701 " <INPUT type=\"text\" id=\"firstname\"/>"
699 " <INPUT type=\"text\" id=\"lastname\"/>" 702 " <INPUT type=\"text\" id=\"lastname\"/>"
700 " <INPUT type=\"hidden\" id=\"imhidden\"/>" 703 " <INPUT type=\"hidden\" id=\"imhidden\"/>"
701 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>" 704 " <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
702 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>" 705 " <INPUT type=\"text\" autocomplete=\"off\" id=\"noautocomplete\"/>"
703 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>" 706 " <INPUT type=\"text\" disabled=\"disabled\" id=\"notenabled\"/>"
(...skipping 19 matching lines...) Expand all
723 // Find the form that contains the input element. 726 // Find the form that contains the input element.
724 FormData form; 727 FormData form;
725 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 728 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
726 &form)); 729 &form));
727 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 730 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
728 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 731 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
729 EXPECT_EQ(GURL("http://buh.com"), form.action); 732 EXPECT_EQ(GURL("http://buh.com"), form.action);
730 733
731 const std::vector<FormField>& fields = form.fields; 734 const std::vector<FormField>& fields = form.fields;
732 ASSERT_EQ(8U, fields.size()); 735 ASSERT_EQ(8U, fields.size());
733 EXPECT_EQ(FormField(string16(), 736
734 ASCIIToUTF16("firstname"), 737 FormField expected;
735 string16(), 738 expected.form_control_type = ASCIIToUTF16("text");
736 ASCIIToUTF16("text"), 739 expected.max_length = WebInputElement::defaultMaxLength();
737 WebInputElement::defaultMaxLength(), 740
738 false), 741 expected.name = ASCIIToUTF16("firstname");
739 fields[0]); 742 expected.value = string16();
740 EXPECT_EQ(FormField(string16(), 743 SCOPED_TRACE("");
741 ASCIIToUTF16("lastname"), 744 ExpectFieldEquals(expected, fields[0]);
742 string16(), 745
743 ASCIIToUTF16("text"), 746 expected.name = ASCIIToUTF16("lastname");
744 WebInputElement::defaultMaxLength(), 747 expected.value = string16();
745 false), 748 SCOPED_TRACE("");
746 fields[1]); 749 ExpectFieldEquals(expected, fields[1]);
747 EXPECT_EQ(FormField(string16(), 750
748 ASCIIToUTF16("notempty"), 751 expected.name = ASCIIToUTF16("notempty");
749 ASCIIToUTF16("Hi"), 752 expected.value = ASCIIToUTF16("Hi");
750 ASCIIToUTF16("text"), 753 SCOPED_TRACE("");
751 WebInputElement::defaultMaxLength(), 754 ExpectFieldEquals(expected, fields[2]);
752 false), 755
753 fields[2]); 756 expected.name = ASCIIToUTF16("noautocomplete");
754 EXPECT_EQ(FormField(string16(), 757 expected.value = string16();
755 ASCIIToUTF16("noautocomplete"), 758 SCOPED_TRACE("");
756 string16(), 759 ExpectFieldEquals(expected, fields[3]);
757 ASCIIToUTF16("text"), 760
758 WebInputElement::defaultMaxLength(), 761 expected.name = ASCIIToUTF16("notenabled");
759 false), 762 expected.value = string16();
760 fields[3]); 763 SCOPED_TRACE("");
761 EXPECT_EQ(FormField(string16(), 764 ExpectFieldEquals(expected, fields[4]);
762 ASCIIToUTF16("notenabled"), 765
763 string16(), 766 expected.name = ASCIIToUTF16("readonly");
764 ASCIIToUTF16("text"), 767 expected.value = string16();
765 WebInputElement::defaultMaxLength(), 768 SCOPED_TRACE("");
766 false), 769 ExpectFieldEquals(expected, fields[5]);
767 fields[4]); 770
768 EXPECT_EQ(FormField(string16(), 771 expected.name = ASCIIToUTF16("invisible");
769 ASCIIToUTF16("readonly"), 772 expected.value = string16();
770 string16(), 773 SCOPED_TRACE("");
771 ASCIIToUTF16("text"), 774 ExpectFieldEquals(expected, fields[6]);
772 WebInputElement::defaultMaxLength(), 775
773 false), 776 expected.name = ASCIIToUTF16("displaynone");
774 fields[5]); 777 expected.value = string16();
775 EXPECT_EQ(FormField(string16(), 778 SCOPED_TRACE("");
776 ASCIIToUTF16("invisible"), 779 ExpectFieldEquals(expected, fields[7]);
777 string16(),
778 ASCIIToUTF16("text"),
779 WebInputElement::defaultMaxLength(),
780 false),
781 fields[6]);
782 EXPECT_EQ(FormField(string16(),
783 ASCIIToUTF16("displaynone"),
784 string16(),
785 ASCIIToUTF16("text"),
786 WebInputElement::defaultMaxLength(),
787 false),
788 fields[7]);
789 780
790 // Fill the form. 781 // Fill the form.
791 form.fields[0].value = ASCIIToUTF16("Wyatt"); 782 form.fields[0].value = ASCIIToUTF16("Wyatt");
792 form.fields[1].value = ASCIIToUTF16("Earp"); 783 form.fields[1].value = ASCIIToUTF16("Earp");
793 form.fields[2].value = ASCIIToUTF16("Alpha"); 784 form.fields[2].value = ASCIIToUTF16("Alpha");
794 form.fields[3].value = ASCIIToUTF16("Beta"); 785 form.fields[3].value = ASCIIToUTF16("Beta");
795 form.fields[4].value = ASCIIToUTF16("Gamma"); 786 form.fields[4].value = ASCIIToUTF16("Gamma");
796 form.fields[5].value = ASCIIToUTF16("Delta"); 787 form.fields[5].value = ASCIIToUTF16("Delta");
797 form.fields[6].value = ASCIIToUTF16("Epsilon"); 788 form.fields[6].value = ASCIIToUTF16("Epsilon");
798 form.fields[7].value = ASCIIToUTF16("Zeta"); 789 form.fields[7].value = ASCIIToUTF16("Zeta");
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after
874 // Find the form that contains the input element. 865 // Find the form that contains the input element.
875 FormData form; 866 FormData form;
876 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 867 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
877 &form)); 868 &form));
878 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 869 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
879 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 870 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
880 EXPECT_EQ(GURL("http://buh.com"), form.action); 871 EXPECT_EQ(GURL("http://buh.com"), form.action);
881 872
882 const std::vector<FormField>& fields = form.fields; 873 const std::vector<FormField>& fields = form.fields;
883 ASSERT_EQ(5U, fields.size()); 874 ASSERT_EQ(5U, fields.size());
884 EXPECT_EQ(FormField(string16(), 875
885 ASCIIToUTF16("firstname"), 876 FormField expected;
886 string16(), 877 expected.form_control_type = ASCIIToUTF16("text");
887 ASCIIToUTF16("text"), 878 expected.max_length = WebInputElement::defaultMaxLength();
888 WebInputElement::defaultMaxLength(), 879
889 false), 880 expected.name = ASCIIToUTF16("firstname");
890 fields[0]); 881 expected.value = string16();
891 EXPECT_EQ(FormField(string16(), 882 SCOPED_TRACE("");
892 ASCIIToUTF16("lastname"), 883 ExpectFieldEquals(expected, fields[0]);
893 string16(), 884
894 ASCIIToUTF16("text"), 885 expected.name = ASCIIToUTF16("lastname");
895 WebInputElement::defaultMaxLength(), 886 expected.value = string16();
896 false), 887 SCOPED_TRACE("");
897 fields[1]); 888 ExpectFieldEquals(expected, fields[1]);
898 EXPECT_EQ(FormField(string16(), 889
899 ASCIIToUTF16("notempty"), 890 expected.name = ASCIIToUTF16("notempty");
900 ASCIIToUTF16("Hi"), 891 expected.value = ASCIIToUTF16("Hi");
901 ASCIIToUTF16("text"), 892 SCOPED_TRACE("");
902 WebInputElement::defaultMaxLength(), 893 ExpectFieldEquals(expected, fields[2]);
903 false), 894
904 fields[2]); 895 expected.name = ASCIIToUTF16("noautocomplete");
905 EXPECT_EQ(FormField(string16(), 896 expected.value = string16();
906 ASCIIToUTF16("noautocomplete"), 897 SCOPED_TRACE("");
907 string16(), 898 ExpectFieldEquals(expected, fields[3]);
908 ASCIIToUTF16("text"), 899
909 WebInputElement::defaultMaxLength(), 900 expected.name = ASCIIToUTF16("notenabled");
910 false), 901 expected.value = string16();
911 fields[3]); 902 SCOPED_TRACE("");
912 EXPECT_EQ(FormField(string16(), 903 ExpectFieldEquals(expected, fields[4]);
913 ASCIIToUTF16("notenabled"),
914 string16(),
915 ASCIIToUTF16("text"),
916 WebInputElement::defaultMaxLength(),
917 false),
918 fields[4]);
919 904
920 // Preview the form. 905 // Preview the form.
921 form.fields[0].value = ASCIIToUTF16("Wyatt"); 906 form.fields[0].value = ASCIIToUTF16("Wyatt");
922 form.fields[1].value = ASCIIToUTF16("Earp"); 907 form.fields[1].value = ASCIIToUTF16("Earp");
923 form.fields[2].value = ASCIIToUTF16("Alpha"); 908 form.fields[2].value = ASCIIToUTF16("Alpha");
924 form.fields[3].value = ASCIIToUTF16("Beta"); 909 form.fields[3].value = ASCIIToUTF16("Beta");
925 form.fields[4].value = ASCIIToUTF16("Gamma"); 910 form.fields[4].value = ASCIIToUTF16("Gamma");
926 form_manager.PreviewForm(form, input_element); 911 form_manager.PreviewForm(form, input_element);
927 912
928 // Verify the previewed elements. 913 // Verify the previewed elements.
(...skipping 187 matching lines...) Expand 10 before | Expand all | Expand 10 after
1116 " </TR>" 1101 " </TR>"
1117 " <TR>" 1102 " <TR>"
1118 " <TD></TD>" 1103 " <TD></TD>"
1119 " <TD>" 1104 " <TD>"
1120 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>" 1105 " <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
1121 " </TD>" 1106 " </TD>"
1122 " </TR>" 1107 " </TR>"
1123 "</TABLE>" 1108 "</TABLE>"
1124 "</FORM>"); 1109 "</FORM>");
1125 } 1110 }
1111
1126 TEST_F(FormManagerTest, LabelsInferredFromTableCellNested) { 1112 TEST_F(FormManagerTest, LabelsInferredFromTableCellNested) {
1127 std::vector<string16> labels, names, values; 1113 std::vector<string16> labels, names, values;
1128 1114
1129 labels.push_back(ASCIIToUTF16("First name: Bogus")); 1115 labels.push_back(ASCIIToUTF16("First name: Bogus"));
1130 names.push_back(ASCIIToUTF16("firstname")); 1116 names.push_back(ASCIIToUTF16("firstname"));
1131 values.push_back(ASCIIToUTF16("John")); 1117 values.push_back(ASCIIToUTF16("John"));
1132 1118
1133 labels.push_back(ASCIIToUTF16("Last name:")); 1119 labels.push_back(ASCIIToUTF16("Last name:"));
1134 names.push_back(ASCIIToUTF16("lastname")); 1120 names.push_back(ASCIIToUTF16("lastname"));
1135 values.push_back(ASCIIToUTF16("Smith")); 1121 values.push_back(ASCIIToUTF16("Smith"));
(...skipping 703 matching lines...) Expand 10 before | Expand all | Expand 10 after
1839 // Find the form that contains the input element. 1825 // Find the form that contains the input element.
1840 FormData form; 1826 FormData form;
1841 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 1827 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
1842 &form)); 1828 &form));
1843 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 1829 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1844 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 1830 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
1845 EXPECT_EQ(GURL("http://buh.com"), form.action); 1831 EXPECT_EQ(GURL("http://buh.com"), form.action);
1846 1832
1847 const std::vector<FormField>& fields = form.fields; 1833 const std::vector<FormField>& fields = form.fields;
1848 ASSERT_EQ(3U, fields.size()); 1834 ASSERT_EQ(3U, fields.size());
1849 EXPECT_EQ(FormField(string16(), 1835
1850 ASCIIToUTF16("firstname"), 1836 FormField expected;
1851 string16(), 1837 expected.form_control_type = ASCIIToUTF16("text");
1852 ASCIIToUTF16("text"), 1838
1853 5, 1839 expected.name = ASCIIToUTF16("firstname");
1854 false), 1840 expected.max_length = 5;
1855 fields[0]); 1841 expected.is_autofilled = false;
1856 EXPECT_EQ(FormField(string16(), 1842 SCOPED_TRACE("");
1857 ASCIIToUTF16("lastname"), 1843 ExpectFieldEquals(expected, fields[0]);
1858 string16(), 1844
1859 ASCIIToUTF16("text"), 1845 expected.name = ASCIIToUTF16("lastname");
1860 7, 1846 expected.max_length = 7;
1861 false), 1847 expected.is_autofilled = false;
1862 fields[1]); 1848 SCOPED_TRACE("");
1863 EXPECT_EQ(FormField(string16(), 1849 ExpectFieldEquals(expected, fields[1]);
1864 ASCIIToUTF16("email"), 1850
1865 string16(), 1851 expected.name = ASCIIToUTF16("email");
1866 ASCIIToUTF16("text"), 1852 expected.max_length = 9;
1867 9, 1853 expected.is_autofilled = false;
1868 false), 1854 SCOPED_TRACE("");
1869 fields[2]); 1855 ExpectFieldEquals(expected, fields[2]);
1870 1856
1871 // Fill the form. 1857 // Fill the form.
1872 form.fields[0].value = ASCIIToUTF16("Brother"); 1858 form.fields[0].value = ASCIIToUTF16("Brother");
1873 form.fields[1].value = ASCIIToUTF16("Jonathan"); 1859 form.fields[1].value = ASCIIToUTF16("Jonathan");
1874 form.fields[2].value = ASCIIToUTF16("brotherj@example.com"); 1860 form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
1875 form_manager.FillForm(form, WebNode()); 1861 form_manager.FillForm(form, WebNode());
1876 1862
1877 // Find the newly-filled form that contains the input element. 1863 // Find the newly-filled form that contains the input element.
1878 FormData form2; 1864 FormData form2;
1879 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 1865 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
1880 &form2)); 1866 &form2));
1881 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 1867 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1882 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 1868 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
1883 EXPECT_EQ(GURL("http://buh.com"), form2.action); 1869 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1884 1870
1885 const std::vector<FormField>& fields2 = form2.fields; 1871 const std::vector<FormField>& fields2 = form2.fields;
1886 ASSERT_EQ(3U, fields2.size()); 1872 ASSERT_EQ(3U, fields2.size());
1887 EXPECT_TRUE(fields2[0].StrictlyEqualsHack(FormField(string16(), 1873
1888 ASCIIToUTF16("firstname"), 1874 expected.form_control_type = ASCIIToUTF16("text");
1889 ASCIIToUTF16("Broth"), 1875
1890 ASCIIToUTF16("text"), 1876 expected.name = ASCIIToUTF16("firstname");
1891 5, 1877 expected.value = ASCIIToUTF16("Broth");
1892 false))); 1878 expected.max_length = 5;
1893 EXPECT_TRUE(fields2[1].StrictlyEqualsHack(FormField(string16(), 1879 expected.is_autofilled = true;
1894 ASCIIToUTF16("lastname"), 1880 SCOPED_TRACE("");
1895 ASCIIToUTF16("Jonatha"), 1881 ExpectFieldEquals(expected, fields2[0]);
1896 ASCIIToUTF16("text"), 1882
1897 7, 1883 expected.name = ASCIIToUTF16("lastname");
1898 false))); 1884 expected.value = ASCIIToUTF16("Jonatha");
1899 EXPECT_TRUE(fields2[2].StrictlyEqualsHack(FormField(string16(), 1885 expected.max_length = 7;
1900 ASCIIToUTF16("email"), 1886 expected.is_autofilled = true;
1901 ASCIIToUTF16("brotherj@"), 1887 SCOPED_TRACE("");
1902 ASCIIToUTF16("text"), 1888 ExpectFieldEquals(expected, fields2[1]);
1903 9, 1889
1904 false))); 1890 expected.name = ASCIIToUTF16("email");
1891 expected.value = ASCIIToUTF16("brotherj@");
1892 expected.max_length = 9;
1893 expected.is_autofilled = true;
1894 SCOPED_TRACE("");
1895 ExpectFieldEquals(expected, fields2[2]);
1905 } 1896 }
1906 1897
1907 // This test uses negative values of the maxlength attribute for input elements. 1898 // This test uses negative values of the maxlength attribute for input elements.
1908 // In this case, the maxlength of the input elements is set to the default 1899 // In this case, the maxlength of the input elements is set to the default
1909 // maxlength (defined in WebKit.) 1900 // maxlength (defined in WebKit.)
1910 TEST_F(FormManagerTest, FillFormNegativeMaxLength) { 1901 TEST_F(FormManagerTest, FillFormNegativeMaxLength) {
1911 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 1902 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
1912 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"-1\"/>" 1903 " <INPUT type=\"text\" id=\"firstname\" maxlength=\"-1\"/>"
1913 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"-10\"/>" 1904 " <INPUT type=\"text\" id=\"lastname\" maxlength=\"-10\"/>"
1914 " <INPUT type=\"text\" id=\"email\" maxlength=\"-13\"/>" 1905 " <INPUT type=\"text\" id=\"email\" maxlength=\"-13\"/>"
(...skipping 15 matching lines...) Expand all
1930 // Find the form that contains the input element. 1921 // Find the form that contains the input element.
1931 FormData form; 1922 FormData form;
1932 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 1923 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
1933 &form)); 1924 &form));
1934 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 1925 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
1935 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 1926 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
1936 EXPECT_EQ(GURL("http://buh.com"), form.action); 1927 EXPECT_EQ(GURL("http://buh.com"), form.action);
1937 1928
1938 const std::vector<FormField>& fields = form.fields; 1929 const std::vector<FormField>& fields = form.fields;
1939 ASSERT_EQ(3U, fields.size()); 1930 ASSERT_EQ(3U, fields.size());
1940 EXPECT_EQ(FormField(string16(), 1931
1941 ASCIIToUTF16("firstname"), 1932 FormField expected;
1942 string16(), 1933 expected.form_control_type = ASCIIToUTF16("text");
1943 ASCIIToUTF16("text"), 1934 expected.max_length = WebInputElement::defaultMaxLength();
1944 WebInputElement::defaultMaxLength(), 1935
1945 false), 1936 expected.name = ASCIIToUTF16("firstname");
1946 fields[0]); 1937 SCOPED_TRACE("");
1947 EXPECT_EQ(FormField(string16(), 1938 ExpectFieldEquals(expected, fields[0]);
1948 ASCIIToUTF16("lastname"), 1939
1949 string16(), 1940 expected.name = ASCIIToUTF16("lastname");
1950 ASCIIToUTF16("text"), 1941 SCOPED_TRACE("");
1951 WebInputElement::defaultMaxLength(), 1942 ExpectFieldEquals(expected, fields[1]);
1952 false), 1943
1953 fields[1]); 1944 expected.name = ASCIIToUTF16("email");
1954 EXPECT_EQ(FormField(string16(), 1945 SCOPED_TRACE("");
1955 ASCIIToUTF16("email"), 1946 ExpectFieldEquals(expected, fields[2]);
1956 string16(),
1957 ASCIIToUTF16("text"),
1958 WebInputElement::defaultMaxLength(),
1959 false),
1960 fields[2]);
1961 1947
1962 // Fill the form. 1948 // Fill the form.
1963 form.fields[0].value = ASCIIToUTF16("Brother"); 1949 form.fields[0].value = ASCIIToUTF16("Brother");
1964 form.fields[1].value = ASCIIToUTF16("Jonathan"); 1950 form.fields[1].value = ASCIIToUTF16("Jonathan");
1965 form.fields[2].value = ASCIIToUTF16("brotherj@example.com"); 1951 form.fields[2].value = ASCIIToUTF16("brotherj@example.com");
1966 form_manager.FillForm(form, WebNode()); 1952 form_manager.FillForm(form, WebNode());
1967 1953
1968 // Find the newly-filled form that contains the input element. 1954 // Find the newly-filled form that contains the input element.
1969 FormData form2; 1955 FormData form2;
1970 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 1956 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
1971 &form2)); 1957 &form2));
1972 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 1958 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
1973 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 1959 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
1974 EXPECT_EQ(GURL("http://buh.com"), form2.action); 1960 EXPECT_EQ(GURL("http://buh.com"), form2.action);
1975 1961
1976 const std::vector<FormField>& fields2 = form2.fields; 1962 const std::vector<FormField>& fields2 = form2.fields;
1977 ASSERT_EQ(3U, fields2.size()); 1963 ASSERT_EQ(3U, fields2.size());
1978 EXPECT_TRUE(fields2[0].StrictlyEqualsHack( 1964
1979 FormField(string16(), 1965 expected.name = ASCIIToUTF16("firstname");
1980 ASCIIToUTF16("firstname"), 1966 expected.value = ASCIIToUTF16("Brother");
1981 ASCIIToUTF16("Brother"), 1967 SCOPED_TRACE("");
1982 ASCIIToUTF16("text"), 1968 ExpectFieldEquals(expected, fields[0]);
1983 WebInputElement::defaultMaxLength(), 1969
1984 false))); 1970 expected.name = ASCIIToUTF16("lastname");
1985 EXPECT_TRUE(fields2[1].StrictlyEqualsHack( 1971 expected.value = ASCIIToUTF16("Jonathan");
1986 FormField(string16(), 1972 SCOPED_TRACE("");
1987 ASCIIToUTF16("lastname"), 1973 ExpectFieldEquals(expected, fields[1]);
1988 ASCIIToUTF16("Jonathan"), 1974
1989 ASCIIToUTF16("text"), 1975 expected.name = ASCIIToUTF16("email");
1990 WebInputElement::defaultMaxLength(), 1976 expected.value = ASCIIToUTF16("brotherj@example.com");
1991 false))); 1977 SCOPED_TRACE("");
1992 EXPECT_TRUE(fields2[2].StrictlyEqualsHack( 1978 ExpectFieldEquals(expected, fields[2]);
1993 FormField(string16(),
1994 ASCIIToUTF16("email"),
1995 ASCIIToUTF16("brotherj@example.com"),
1996 ASCIIToUTF16("text"),
1997 WebInputElement::defaultMaxLength(),
1998 false)));
1999 } 1979 }
2000 1980
2001 // This test sends a FormData object to FillForm with more fields than are in 1981 // This test sends a FormData object to FillForm with more fields than are in
2002 // the cached WebFormElement. In this case, we only fill out the fields that 1982 // the cached WebFormElement. In this case, we only fill out the fields that
2003 // match between the FormData object and the WebFormElement. 1983 // match between the FormData object and the WebFormElement.
2004 TEST_F(FormManagerTest, FillFormMoreFormDataFields) { 1984 TEST_F(FormManagerTest, FillFormMoreFormDataFields) {
2005 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 1985 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2006 " <INPUT type=\"text\" id=\"firstname\"/>" 1986 " <INPUT type=\"text\" id=\"firstname\"/>"
2007 " <INPUT type=\"text\" id=\"middlename\"/>" 1987 " <INPUT type=\"text\" id=\"middlename\"/>"
2008 " <INPUT type=\"text\" id=\"lastname\"/>" 1988 " <INPUT type=\"text\" id=\"lastname\"/>"
(...skipping 11 matching lines...) Expand all
2020 // After the field modification, the fields in |form| will look like: 2000 // After the field modification, the fields in |form| will look like:
2021 // prefix 2001 // prefix
2022 // firstname 2002 // firstname
2023 // hidden 2003 // hidden
2024 // middlename 2004 // middlename
2025 // second 2005 // second
2026 // lastname 2006 // lastname
2027 // postfix 2007 // postfix
2028 FormData* form = &forms[0]; 2008 FormData* form = &forms[0];
2029 2009
2030 FormField field1(string16(), 2010 FormField field1;
2031 ASCIIToUTF16("prefix"), 2011 field1.name = ASCIIToUTF16("prefix");
2032 string16(), 2012 field1.form_control_type = ASCIIToUTF16("text");
2033 ASCIIToUTF16("text"), 2013 field1.max_length = WebInputElement::defaultMaxLength();
2034 WebInputElement::defaultMaxLength(),
2035 false);
2036 form->fields.insert(form->fields.begin(), field1); 2014 form->fields.insert(form->fields.begin(), field1);
2037 2015
2038 FormField field2(string16(), 2016 FormField field2;
2039 ASCIIToUTF16("hidden"), 2017 field2.name = ASCIIToUTF16("hidden");
2040 string16(), 2018 field2.form_control_type = ASCIIToUTF16("text");
2041 ASCIIToUTF16("text"), 2019 field2.max_length = WebInputElement::defaultMaxLength();
2042 WebInputElement::defaultMaxLength(),
2043 false);
2044 form->fields.insert(form->fields.begin() + 2, field2); 2020 form->fields.insert(form->fields.begin() + 2, field2);
2045 2021
2046 FormField field3(string16(), 2022 FormField field3;
2047 ASCIIToUTF16("second"), 2023 field3.name = ASCIIToUTF16("second");
2048 string16(), 2024 field3.form_control_type = ASCIIToUTF16("text");
2049 ASCIIToUTF16("text"), 2025 field3.max_length = WebInputElement::defaultMaxLength();
2050 WebInputElement::defaultMaxLength(),
2051 false);
2052 form->fields.insert(form->fields.begin() + 4, field3); 2026 form->fields.insert(form->fields.begin() + 4, field3);
2053 2027
2054 FormField field4(string16(), 2028 FormField field4;
2055 ASCIIToUTF16("postfix"), 2029 field4.name = ASCIIToUTF16("postfix");
2056 string16(), 2030 field4.form_control_type = ASCIIToUTF16("text");
2057 ASCIIToUTF16("text"), 2031 field4.max_length = WebInputElement::defaultMaxLength();
2058 WebInputElement::defaultMaxLength(),
2059 false);
2060 form->fields.insert(form->fields.begin() + 6, field4); 2032 form->fields.insert(form->fields.begin() + 6, field4);
2061 2033
2062 // Fill the form. 2034 // Fill the form.
2063 form->fields[0].value = ASCIIToUTF16("Alpha"); 2035 form->fields[0].value = ASCIIToUTF16("Alpha");
2064 form->fields[1].value = ASCIIToUTF16("Brother"); 2036 form->fields[1].value = ASCIIToUTF16("Brother");
2065 form->fields[2].value = ASCIIToUTF16("Abracadabra"); 2037 form->fields[2].value = ASCIIToUTF16("Abracadabra");
2066 form->fields[3].value = ASCIIToUTF16("Joseph"); 2038 form->fields[3].value = ASCIIToUTF16("Joseph");
2067 form->fields[4].value = ASCIIToUTF16("Beta"); 2039 form->fields[4].value = ASCIIToUTF16("Beta");
2068 form->fields[5].value = ASCIIToUTF16("Jonathan"); 2040 form->fields[5].value = ASCIIToUTF16("Jonathan");
2069 form->fields[6].value = ASCIIToUTF16("Omega"); 2041 form->fields[6].value = ASCIIToUTF16("Omega");
2070 form_manager.FillForm(*form, WebNode()); 2042 form_manager.FillForm(*form, WebNode());
2071 2043
2072 // Get the input element we want to find. 2044 // Get the input element we want to find.
2073 WebElement element = web_frame->document().getElementById("firstname"); 2045 WebElement element = web_frame->document().getElementById("firstname");
2074 WebInputElement input_element = element.to<WebInputElement>(); 2046 WebInputElement input_element = element.to<WebInputElement>();
2075 2047
2076 // Find the newly-filled form that contains the input element. 2048 // Find the newly-filled form that contains the input element.
2077 FormData form2; 2049 FormData form2;
2078 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2050 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2079 &form2)); 2051 &form2));
2080 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2052 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2081 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2053 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2082 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2054 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2083 2055
2084 const std::vector<FormField>& fields = form2.fields; 2056 const std::vector<FormField>& fields = form2.fields;
2085 ASSERT_EQ(3U, fields.size()); 2057 ASSERT_EQ(3U, fields.size());
2086 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 2058
2087 FormField(string16(), 2059 FormField expected;
2088 ASCIIToUTF16("firstname"), 2060 expected.form_control_type = ASCIIToUTF16("text");
2089 ASCIIToUTF16("Brother"), 2061 expected.max_length = WebInputElement::defaultMaxLength();
2090 ASCIIToUTF16("text"), 2062 expected.is_autofilled = true;
2091 WebInputElement::defaultMaxLength(), 2063
2092 false))); 2064 expected.name = ASCIIToUTF16("firstname");
2093 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 2065 expected.value = ASCIIToUTF16("Brother");
2094 FormField(string16(), 2066 SCOPED_TRACE("");
2095 ASCIIToUTF16("middlename"), 2067 ExpectFieldEquals(expected, fields[0]);
2096 ASCIIToUTF16("Joseph"), 2068
2097 ASCIIToUTF16("text"), 2069 expected.name = ASCIIToUTF16("middlename");
2098 WebInputElement::defaultMaxLength(), 2070 expected.value = ASCIIToUTF16("Joseph");
2099 false))); 2071 SCOPED_TRACE("");
2100 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 2072 ExpectFieldEquals(expected, fields[1]);
2101 FormField(string16(), 2073
2102 ASCIIToUTF16("lastname"), 2074 expected.name = ASCIIToUTF16("lastname");
2103 ASCIIToUTF16("Jonathan"), 2075 expected.value = ASCIIToUTF16("Jonathan");
2104 ASCIIToUTF16("text"), 2076 SCOPED_TRACE("");
2105 WebInputElement::defaultMaxLength(), 2077 ExpectFieldEquals(expected, fields[2]);
2106 false)));
2107 } 2078 }
2108 2079
2109 // This test sends a FormData object to FillForm with fewer fields than are in 2080 // This test sends a FormData object to FillForm with fewer fields than are in
2110 // the cached WebFormElement. In this case, we only fill out the fields that 2081 // the cached WebFormElement. In this case, we only fill out the fields that
2111 // match between the FormData object and the WebFormElement. 2082 // match between the FormData object and the WebFormElement.
2112 TEST_F(FormManagerTest, FillFormFewerFormDataFields) { 2083 TEST_F(FormManagerTest, FillFormFewerFormDataFields) {
2113 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2084 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2114 " <INPUT type=\"text\" id=\"prefix\"/>" 2085 " <INPUT type=\"text\" id=\"prefix\"/>"
2115 " <INPUT type=\"text\" id=\"firstname\"/>" 2086 " <INPUT type=\"text\" id=\"firstname\"/>"
2116 " <INPUT type=\"text\" id=\"hidden\"/>" 2087 " <INPUT type=\"text\" id=\"hidden\"/>"
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2152 // Find the newly-filled form that contains the input element. 2123 // Find the newly-filled form that contains the input element.
2153 FormData form2; 2124 FormData form2;
2154 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2125 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2155 &form2)); 2126 &form2));
2156 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2127 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2157 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2128 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2158 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2129 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2159 2130
2160 const std::vector<FormField>& fields = form2.fields; 2131 const std::vector<FormField>& fields = form2.fields;
2161 ASSERT_EQ(7U, fields.size()); 2132 ASSERT_EQ(7U, fields.size());
2162 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 2133
2163 FormField(string16(), 2134 FormField expected;
2164 ASCIIToUTF16("prefix"), 2135 expected.form_control_type = ASCIIToUTF16("text");
2165 string16(), 2136 expected.max_length = WebInputElement::defaultMaxLength();
2166 ASCIIToUTF16("text"), 2137
2167 WebInputElement::defaultMaxLength(), 2138 expected.name = ASCIIToUTF16("prefix");
2168 false))); 2139 expected.value = string16();
2169 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 2140 expected.is_autofilled = false;
2170 FormField(string16(), 2141 SCOPED_TRACE("");
2171 ASCIIToUTF16("firstname"), 2142 ExpectFieldEquals(expected, fields[0]);
2172 ASCIIToUTF16("Brother"), 2143
2173 ASCIIToUTF16("text"), 2144 expected.name = ASCIIToUTF16("firstname");
2174 WebInputElement::defaultMaxLength(), 2145 expected.value = ASCIIToUTF16("Brother");
2175 false))); 2146 expected.is_autofilled = true;
2176 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 2147 SCOPED_TRACE("");
2177 FormField(string16(), 2148 ExpectFieldEquals(expected, fields[1]);
2178 ASCIIToUTF16("hidden"), 2149
2179 string16(), 2150 expected.name = ASCIIToUTF16("hidden");
2180 ASCIIToUTF16("text"), 2151 expected.value = string16();
2181 WebInputElement::defaultMaxLength(), 2152 expected.is_autofilled = false;
2182 false))); 2153 SCOPED_TRACE("");
2183 EXPECT_TRUE(fields[3].StrictlyEqualsHack( 2154 ExpectFieldEquals(expected, fields[2]);
2184 FormField(string16(), 2155
2185 ASCIIToUTF16("middlename"), 2156 expected.name = ASCIIToUTF16("middlename");
2186 ASCIIToUTF16("Joseph"), 2157 expected.value = ASCIIToUTF16("Joseph");
2187 ASCIIToUTF16("text"), 2158 expected.is_autofilled = true;
2188 WebInputElement::defaultMaxLength(), 2159 SCOPED_TRACE("");
2189 false))); 2160 ExpectFieldEquals(expected, fields[3]);
2190 EXPECT_TRUE(fields[4].StrictlyEqualsHack( 2161
2191 FormField(string16(), 2162 expected.name = ASCIIToUTF16("second");
2192 ASCIIToUTF16("second"), 2163 expected.value = string16();
2193 string16(), 2164 expected.is_autofilled = false;
2194 ASCIIToUTF16("text"), 2165 SCOPED_TRACE("");
2195 WebInputElement::defaultMaxLength(), 2166 ExpectFieldEquals(expected, fields[4]);
2196 false))); 2167
2197 EXPECT_TRUE(fields[5].StrictlyEqualsHack( 2168 expected.name = ASCIIToUTF16("lastname");
2198 FormField(string16(), 2169 expected.value = ASCIIToUTF16("Jonathan");
2199 ASCIIToUTF16("lastname"), 2170 expected.is_autofilled = true;
2200 ASCIIToUTF16("Jonathan"), 2171 SCOPED_TRACE("");
2201 ASCIIToUTF16("text"), 2172 ExpectFieldEquals(expected, fields[5]);
2202 WebInputElement::defaultMaxLength(), 2173
2203 false))); 2174 expected.name = ASCIIToUTF16("postfix");
2204 EXPECT_TRUE(fields[6].StrictlyEqualsHack( 2175 expected.value = string16();
2205 FormField(string16(), 2176 expected.is_autofilled = false;
2206 ASCIIToUTF16("postfix"), 2177 SCOPED_TRACE("");
2207 string16(), 2178 ExpectFieldEquals(expected, fields[6]);
2208 ASCIIToUTF16("text"),
2209 WebInputElement::defaultMaxLength(),
2210 false)));
2211 } 2179 }
2212 2180
2213 // This test sends a FormData object to FillForm with a field changed from 2181 // This test sends a FormData object to FillForm with a field changed from
2214 // those in the cached WebFormElement. In this case, we only fill out the 2182 // those in the cached WebFormElement. In this case, we only fill out the
2215 // fields that match between the FormData object and the WebFormElement. 2183 // fields that match between the FormData object and the WebFormElement.
2216 TEST_F(FormManagerTest, FillFormChangedFormDataFields) { 2184 TEST_F(FormManagerTest, FillFormChangedFormDataFields) {
2217 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2185 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2218 " <INPUT type=\"text\" id=\"firstname\"/>" 2186 " <INPUT type=\"text\" id=\"firstname\"/>"
2219 " <INPUT type=\"text\" id=\"middlename\"/>" 2187 " <INPUT type=\"text\" id=\"middlename\"/>"
2220 " <INPUT type=\"text\" id=\"lastname\"/>" 2188 " <INPUT type=\"text\" id=\"lastname\"/>"
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
2253 // Find the newly-filled form that contains the input element. 2221 // Find the newly-filled form that contains the input element.
2254 FormData form2; 2222 FormData form2;
2255 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2223 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2256 &form2)); 2224 &form2));
2257 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2225 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2258 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2226 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2259 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2227 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2260 2228
2261 const std::vector<FormField>& fields = form2.fields; 2229 const std::vector<FormField>& fields = form2.fields;
2262 ASSERT_EQ(3U, fields.size()); 2230 ASSERT_EQ(3U, fields.size());
2263 EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(), 2231
2264 ASCIIToUTF16("firstname"), 2232 FormField expected;
2265 ASCIIToUTF16("Brother"), 2233 expected.form_control_type = ASCIIToUTF16("text");
2266 ASCIIToUTF16("text"), 2234 expected.max_length = WebInputElement::defaultMaxLength();
2267 WebInputElement::defaultMaxLength(), 2235
2268 false))); 2236 expected.name = ASCIIToUTF16("firstname");
2269 EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(), 2237 expected.value = ASCIIToUTF16("Brother");
2270 ASCIIToUTF16("middlename"), 2238 expected.is_autofilled = true;
2271 string16(), 2239 SCOPED_TRACE("");
2272 ASCIIToUTF16("text"), 2240 ExpectFieldEquals(expected, fields[0]);
2273 WebInputElement::defaultMaxLength(), 2241
2274 false))); 2242 expected.name = ASCIIToUTF16("middlename");
2275 EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(), 2243 expected.value = ASCIIToUTF16("");
2276 ASCIIToUTF16("lastname"), 2244 expected.is_autofilled = false;
2277 ASCIIToUTF16("Jonathan"), 2245 SCOPED_TRACE("");
2278 ASCIIToUTF16("text"), 2246 ExpectFieldEquals(expected, fields[1]);
2279 WebInputElement::defaultMaxLength(), 2247
2280 false))); 2248 expected.name = ASCIIToUTF16("lastname");
2249 expected.value = ASCIIToUTF16("Jonathan");
2250 expected.is_autofilled = true;
2251 SCOPED_TRACE("");
2252 ExpectFieldEquals(expected, fields[2]);
2281 } 2253 }
2282 2254
2283 // This test sends a FormData object to FillForm with fewer fields than are in 2255 // This test sends a FormData object to FillForm with fewer fields than are in
2284 // the cached WebFormElement. In this case, we only fill out the fields that 2256 // the cached WebFormElement. In this case, we only fill out the fields that
2285 // match between the FormData object and the WebFormElement. 2257 // match between the FormData object and the WebFormElement.
2286 TEST_F(FormManagerTest, FillFormExtraFieldInCache) { 2258 TEST_F(FormManagerTest, FillFormExtraFieldInCache) {
2287 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2259 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2288 " <INPUT type=\"text\" id=\"firstname\"/>" 2260 " <INPUT type=\"text\" id=\"firstname\"/>"
2289 " <INPUT type=\"text\" id=\"middlename\"/>" 2261 " <INPUT type=\"text\" id=\"middlename\"/>"
2290 " <INPUT type=\"text\" id=\"lastname\"/>" 2262 " <INPUT type=\"text\" id=\"lastname\"/>"
(...skipping 29 matching lines...) Expand all
2320 // Find the newly-filled form that contains the input element. 2292 // Find the newly-filled form that contains the input element.
2321 FormData form2; 2293 FormData form2;
2322 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2294 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2323 &form2)); 2295 &form2));
2324 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2296 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2325 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2297 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2326 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2298 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2327 2299
2328 const std::vector<FormField>& fields = form2.fields; 2300 const std::vector<FormField>& fields = form2.fields;
2329 ASSERT_EQ(4U, fields.size()); 2301 ASSERT_EQ(4U, fields.size());
2330 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 2302
2331 FormField(string16(), 2303 FormField expected;
2332 ASCIIToUTF16("firstname"), 2304 expected.form_control_type = ASCIIToUTF16("text");
2333 ASCIIToUTF16("Brother"), 2305 expected.max_length = WebInputElement::defaultMaxLength();
2334 ASCIIToUTF16("text"), 2306
2335 WebInputElement::defaultMaxLength(), 2307 expected.name = ASCIIToUTF16("firstname");
2336 false))); 2308 expected.value = ASCIIToUTF16("Brother");
2337 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 2309 expected.is_autofilled = true;
2338 FormField(string16(), 2310 SCOPED_TRACE("");
2339 ASCIIToUTF16("middlename"), 2311 ExpectFieldEquals(expected, fields[0]);
2340 ASCIIToUTF16("Joseph"), 2312
2341 ASCIIToUTF16("text"), 2313 expected.name = ASCIIToUTF16("middlename");
2342 WebInputElement::defaultMaxLength(), 2314 expected.value = ASCIIToUTF16("Joseph");
2343 false))); 2315 expected.is_autofilled = true;
2344 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 2316 SCOPED_TRACE("");
2345 FormField(string16(), 2317 ExpectFieldEquals(expected, fields[1]);
2346 ASCIIToUTF16("lastname"), 2318
2347 ASCIIToUTF16("Jonathan"), 2319 expected.name = ASCIIToUTF16("lastname");
2348 ASCIIToUTF16("text"), 2320 expected.value = ASCIIToUTF16("Jonathan");
2349 WebInputElement::defaultMaxLength(), 2321 expected.is_autofilled = true;
2350 false))); 2322 SCOPED_TRACE("");
2351 EXPECT_TRUE(fields[3].StrictlyEqualsHack( 2323 ExpectFieldEquals(expected, fields[2]);
2352 FormField(string16(), 2324
2353 ASCIIToUTF16("postfix"), 2325 expected.name = ASCIIToUTF16("postfix");
2354 string16(), 2326 expected.value = string16();
2355 ASCIIToUTF16("text"), 2327 expected.is_autofilled = false;
2356 WebInputElement::defaultMaxLength(), 2328 SCOPED_TRACE("");
2357 false))); 2329 ExpectFieldEquals(expected, fields[3]);
2358 } 2330 }
2359 2331
2360 TEST_F(FormManagerTest, FillFormEmptyName) { 2332 TEST_F(FormManagerTest, FillFormEmptyName) {
2361 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2333 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2362 " <INPUT type=\"text\" id=\"firstname\"/>" 2334 " <INPUT type=\"text\" id=\"firstname\"/>"
2363 " <INPUT type=\"text\" id=\"lastname\"/>" 2335 " <INPUT type=\"text\" id=\"lastname\"/>"
2364 " <INPUT type=\"text\" id=\"email\"/>" 2336 " <INPUT type=\"text\" id=\"email\"/>"
2365 " <INPUT type=\"submit\" value=\"Send\"/>" 2337 " <INPUT type=\"submit\" value=\"Send\"/>"
2366 "</FORM>"); 2338 "</FORM>");
2367 2339
(...skipping 12 matching lines...) Expand all
2380 // Find the form that contains the input element. 2352 // Find the form that contains the input element.
2381 FormData form; 2353 FormData form;
2382 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2354 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2383 &form)); 2355 &form));
2384 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2356 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2385 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2357 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
2386 EXPECT_EQ(GURL("http://buh.com"), form.action); 2358 EXPECT_EQ(GURL("http://buh.com"), form.action);
2387 2359
2388 const std::vector<FormField>& fields = form.fields; 2360 const std::vector<FormField>& fields = form.fields;
2389 ASSERT_EQ(3U, fields.size()); 2361 ASSERT_EQ(3U, fields.size());
2390 EXPECT_EQ(FormField(string16(), 2362
2391 ASCIIToUTF16("firstname"), 2363 FormField expected;
2392 string16(), 2364 expected.form_control_type = ASCIIToUTF16("text");
2393 ASCIIToUTF16("text"), 2365 expected.max_length = WebInputElement::defaultMaxLength();
2394 WebInputElement::defaultMaxLength(), 2366
2395 false), 2367 expected.name = ASCIIToUTF16("firstname");
2396 fields[0]); 2368 SCOPED_TRACE("");
2397 EXPECT_EQ(FormField(string16(), 2369 ExpectFieldEquals(expected, fields[0]);
2398 ASCIIToUTF16("lastname"), 2370
2399 string16(), 2371 expected.name = ASCIIToUTF16("lastname");
2400 ASCIIToUTF16("text"), 2372 SCOPED_TRACE("");
2401 WebInputElement::defaultMaxLength(), 2373 ExpectFieldEquals(expected, fields[1]);
2402 false), 2374
2403 fields[1]); 2375 expected.name = ASCIIToUTF16("email");
2404 EXPECT_EQ(FormField(string16(), 2376 SCOPED_TRACE("");
2405 ASCIIToUTF16("email"), 2377 ExpectFieldEquals(expected, fields[2]);
2406 string16(),
2407 ASCIIToUTF16("text"),
2408 WebInputElement::defaultMaxLength(),
2409 false),
2410 fields[2]);
2411 2378
2412 // Fill the form. 2379 // Fill the form.
2413 form.fields[0].value = ASCIIToUTF16("Wyatt"); 2380 form.fields[0].value = ASCIIToUTF16("Wyatt");
2414 form.fields[1].value = ASCIIToUTF16("Earp"); 2381 form.fields[1].value = ASCIIToUTF16("Earp");
2415 form.fields[2].value = ASCIIToUTF16("wyatt@example.com"); 2382 form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
2416 form_manager.FillForm(form, WebNode()); 2383 form_manager.FillForm(form, WebNode());
2417 2384
2418 // Find the newly-filled form that contains the input element. 2385 // Find the newly-filled form that contains the input element.
2419 FormData form2; 2386 FormData form2;
2420 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2387 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2421 &form2)); 2388 &form2));
2422 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2389 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2423 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2390 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2424 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2391 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2425 2392
2426 const std::vector<FormField>& fields2 = form2.fields; 2393 const std::vector<FormField>& fields2 = form2.fields;
2427 ASSERT_EQ(3U, fields2.size()); 2394 ASSERT_EQ(3U, fields2.size());
2428 EXPECT_EQ(FormField(string16(), 2395
2429 ASCIIToUTF16("firstname"), 2396 expected.form_control_type = ASCIIToUTF16("text");
2430 ASCIIToUTF16("Wyatt"), 2397 expected.max_length = WebInputElement::defaultMaxLength();
2431 ASCIIToUTF16("text"), 2398
2432 WebInputElement::defaultMaxLength(), 2399 expected.name = ASCIIToUTF16("firstname");
2433 false), 2400 expected.value = ASCIIToUTF16("Wyatt");
2434 fields2[0]); 2401 SCOPED_TRACE("");
2435 EXPECT_EQ(FormField(string16(), 2402 ExpectFieldEquals(expected, fields[0]);
2436 ASCIIToUTF16("lastname"), 2403
2437 ASCIIToUTF16("Earp"), 2404 expected.name = ASCIIToUTF16("lastname");
2438 ASCIIToUTF16("text"), 2405 expected.value = ASCIIToUTF16("Earp");
2439 WebInputElement::defaultMaxLength(), 2406 SCOPED_TRACE("");
2440 false), 2407 ExpectFieldEquals(expected, fields[1]);
2441 fields2[1]); 2408
2442 EXPECT_EQ(FormField(string16(), 2409 expected.name = ASCIIToUTF16("email");
2443 ASCIIToUTF16("email"), 2410 expected.value = ASCIIToUTF16("wyatt@example.com");
2444 ASCIIToUTF16("wyatt@example.com"), 2411 SCOPED_TRACE("");
2445 ASCIIToUTF16("text"), 2412 ExpectFieldEquals(expected, fields[2]);
2446 WebInputElement::defaultMaxLength(),
2447 false),
2448 fields2[2]);
2449 } 2413 }
2450 2414
2451 TEST_F(FormManagerTest, FillFormEmptyFormNames) { 2415 TEST_F(FormManagerTest, FillFormEmptyFormNames) {
2452 LoadHTML("<FORM action=\"http://buh.com\" method=\"post\">" 2416 LoadHTML("<FORM action=\"http://buh.com\" method=\"post\">"
2453 " <INPUT type=\"text\" id=\"firstname\"/>" 2417 " <INPUT type=\"text\" id=\"firstname\"/>"
2454 " <INPUT type=\"text\" id=\"middlename\"/>" 2418 " <INPUT type=\"text\" id=\"middlename\"/>"
2455 " <INPUT type=\"text\" id=\"lastname\"/>" 2419 " <INPUT type=\"text\" id=\"lastname\"/>"
2456 " <INPUT type=\"submit\" value=\"Send\"/>" 2420 " <INPUT type=\"submit\" value=\"Send\"/>"
2457 "</FORM>" 2421 "</FORM>"
2458 "<FORM action=\"http://abc.com\" method=\"post\">" 2422 "<FORM action=\"http://abc.com\" method=\"post\">"
(...skipping 18 matching lines...) Expand all
2477 // Find the form that contains the input element. 2441 // Find the form that contains the input element.
2478 FormData form; 2442 FormData form;
2479 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2443 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2480 &form)); 2444 &form));
2481 EXPECT_EQ(string16(), form.name); 2445 EXPECT_EQ(string16(), form.name);
2482 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2446 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
2483 EXPECT_EQ(GURL("http://abc.com"), form.action); 2447 EXPECT_EQ(GURL("http://abc.com"), form.action);
2484 2448
2485 const std::vector<FormField>& fields = form.fields; 2449 const std::vector<FormField>& fields = form.fields;
2486 ASSERT_EQ(3U, fields.size()); 2450 ASSERT_EQ(3U, fields.size());
2487 EXPECT_EQ(FormField(string16(), 2451
2488 ASCIIToUTF16("apple"), 2452 FormField expected;
2489 string16(), 2453 expected.form_control_type = ASCIIToUTF16("text");
2490 ASCIIToUTF16("text"), 2454 expected.max_length = WebInputElement::defaultMaxLength();
2491 WebInputElement::defaultMaxLength(), 2455
2492 false), 2456 expected.name = ASCIIToUTF16("apple");
2493 fields[0]); 2457 expected.is_autofilled = false;
2494 EXPECT_EQ(FormField(string16(), 2458 SCOPED_TRACE("");
2495 ASCIIToUTF16("banana"), 2459 ExpectFieldEquals(expected, fields[0]);
2496 string16(), 2460
2497 ASCIIToUTF16("text"), 2461 expected.name = ASCIIToUTF16("banana");
2498 WebInputElement::defaultMaxLength(), 2462 expected.is_autofilled = false;
2499 false), 2463 SCOPED_TRACE("");
2500 fields[1]); 2464 ExpectFieldEquals(expected, fields[1]);
2501 EXPECT_EQ(FormField(string16(), 2465
2502 ASCIIToUTF16("cantelope"), 2466 expected.name = ASCIIToUTF16("cantelope");
2503 string16(), 2467 expected.is_autofilled = false;
2504 ASCIIToUTF16("text"), 2468 SCOPED_TRACE("");
2505 WebInputElement::defaultMaxLength(), 2469 ExpectFieldEquals(expected, fields[2]);
2506 false),
2507 fields[2]);
2508 2470
2509 // Fill the form. 2471 // Fill the form.
2510 form.fields[0].value = ASCIIToUTF16("Red"); 2472 form.fields[0].value = ASCIIToUTF16("Red");
2511 form.fields[1].value = ASCIIToUTF16("Yellow"); 2473 form.fields[1].value = ASCIIToUTF16("Yellow");
2512 form.fields[2].value = ASCIIToUTF16("Also Yellow"); 2474 form.fields[2].value = ASCIIToUTF16("Also Yellow");
2513 form_manager.FillForm(form, WebNode()); 2475 form_manager.FillForm(form, WebNode());
2514 2476
2515 // Find the newly-filled form that contains the input element. 2477 // Find the newly-filled form that contains the input element.
2516 FormData form2; 2478 FormData form2;
2517 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2479 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2518 &form2)); 2480 &form2));
2519 EXPECT_EQ(string16(), form2.name); 2481 EXPECT_EQ(string16(), form2.name);
2520 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2482 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2521 EXPECT_EQ(GURL("http://abc.com"), form2.action); 2483 EXPECT_EQ(GURL("http://abc.com"), form2.action);
2522 2484
2523 const std::vector<FormField>& fields2 = form2.fields; 2485 const std::vector<FormField>& fields2 = form2.fields;
2524 ASSERT_EQ(3U, fields2.size()); 2486 ASSERT_EQ(3U, fields2.size());
2525 EXPECT_EQ(FormField(string16(), 2487
2526 ASCIIToUTF16("apple"), 2488 expected.name = ASCIIToUTF16("apple");
2527 ASCIIToUTF16("Red"), 2489 expected.value = ASCIIToUTF16("Red");
2528 ASCIIToUTF16("text"), 2490 expected.is_autofilled = true;
2529 WebInputElement::defaultMaxLength(), 2491 SCOPED_TRACE("");
2530 false), 2492 ExpectFieldEquals(expected, fields2[0]);
2531 fields2[0]); 2493
2532 EXPECT_EQ(FormField(string16(), 2494 expected.name = ASCIIToUTF16("banana");
2533 ASCIIToUTF16("banana"), 2495 expected.value = ASCIIToUTF16("Yellow");
2534 ASCIIToUTF16("Yellow"), 2496 expected.is_autofilled = true;
2535 ASCIIToUTF16("text"), 2497 SCOPED_TRACE("");
2536 WebInputElement::defaultMaxLength(), 2498 ExpectFieldEquals(expected, fields2[1]);
2537 false), 2499
2538 fields2[1]); 2500 expected.name = ASCIIToUTF16("cantelope");
2539 EXPECT_EQ(FormField(string16(), 2501 expected.value = ASCIIToUTF16("Also Yellow");
2540 ASCIIToUTF16("cantelope"), 2502 expected.is_autofilled = true;
2541 ASCIIToUTF16("Also Yellow"), 2503 SCOPED_TRACE("");
2542 ASCIIToUTF16("text"), 2504 ExpectFieldEquals(expected, fields2[2]);
2543 WebInputElement::defaultMaxLength(),
2544 false),
2545 fields2[2]);
2546 } 2505 }
2547 2506
2548 TEST_F(FormManagerTest, ThreePartPhone) { 2507 TEST_F(FormManagerTest, ThreePartPhone) {
2549 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 2508 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
2550 " Phone:" 2509 " Phone:"
2551 " <input type=\"text\" name=\"dayphone1\">" 2510 " <input type=\"text\" name=\"dayphone1\">"
2552 " -" 2511 " -"
2553 " <input type=\"text\" name=\"dayphone2\">" 2512 " <input type=\"text\" name=\"dayphone2\">"
2554 " -" 2513 " -"
2555 " <input type=\"text\" name=\"dayphone3\">" 2514 " <input type=\"text\" name=\"dayphone3\">"
(...skipping 14 matching lines...) Expand all
2570 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0], 2529 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
2571 FormManager::REQUIRE_NONE, 2530 FormManager::REQUIRE_NONE,
2572 FormManager::EXTRACT_VALUE, 2531 FormManager::EXTRACT_VALUE,
2573 &form)); 2532 &form));
2574 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2533 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2575 EXPECT_EQ(GURL(frame->document().url()), form.origin); 2534 EXPECT_EQ(GURL(frame->document().url()), form.origin);
2576 EXPECT_EQ(GURL("http://cnn.com"), form.action); 2535 EXPECT_EQ(GURL("http://cnn.com"), form.action);
2577 2536
2578 const std::vector<FormField>& fields = form.fields; 2537 const std::vector<FormField>& fields = form.fields;
2579 ASSERT_EQ(4U, fields.size()); 2538 ASSERT_EQ(4U, fields.size());
2580 EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"), 2539
2581 ASCIIToUTF16("dayphone1"), 2540 FormField expected;
2582 string16(), 2541 expected.form_control_type = ASCIIToUTF16("text");
2583 ASCIIToUTF16("text"), 2542 expected.max_length = WebInputElement::defaultMaxLength();
2584 WebInputElement::defaultMaxLength(), 2543
2585 false), 2544 expected.label = ASCIIToUTF16("Phone:");
2586 fields[0]); 2545 expected.name = ASCIIToUTF16("dayphone1");
2587 EXPECT_EQ(FormField(ASCIIToUTF16("-"), 2546 SCOPED_TRACE("");
2588 ASCIIToUTF16("dayphone2"), 2547 ExpectFieldEquals(expected, fields[0]);
2589 string16(), 2548
2590 ASCIIToUTF16("text"), 2549 expected.label = ASCIIToUTF16("-");
2591 WebInputElement::defaultMaxLength(), 2550 expected.name = ASCIIToUTF16("dayphone2");
2592 false), 2551 SCOPED_TRACE("");
2593 fields[1]); 2552 ExpectFieldEquals(expected, fields[1]);
2594 EXPECT_EQ(FormField(ASCIIToUTF16("-"), 2553
2595 ASCIIToUTF16("dayphone3"), 2554 expected.label = ASCIIToUTF16("-");
2596 string16(), 2555 expected.name = ASCIIToUTF16("dayphone3");
2597 ASCIIToUTF16("text"), 2556 SCOPED_TRACE("");
2598 WebInputElement::defaultMaxLength(), 2557 ExpectFieldEquals(expected, fields[2]);
2599 false), 2558
2600 fields[2]); 2559 expected.label = ASCIIToUTF16("ext.:");
2601 EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"), 2560 expected.name = ASCIIToUTF16("dayphone4");
2602 ASCIIToUTF16("dayphone4"), 2561 SCOPED_TRACE("");
2603 string16(), 2562 ExpectFieldEquals(expected, fields[3]);
2604 ASCIIToUTF16("text"),
2605 WebInputElement::defaultMaxLength(),
2606 false),
2607 fields[3]);
2608 } 2563 }
2609 2564
2610 2565
2611 TEST_F(FormManagerTest, MaxLengthFields) { 2566 TEST_F(FormManagerTest, MaxLengthFields) {
2612 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">" 2567 LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
2613 " Phone:" 2568 " Phone:"
2614 " <input type=\"text\" maxlength=\"3\" name=\"dayphone1\">" 2569 " <input type=\"text\" maxlength=\"3\" name=\"dayphone1\">"
2615 " -" 2570 " -"
2616 " <input type=\"text\" maxlength=\"3\" name=\"dayphone2\">" 2571 " <input type=\"text\" maxlength=\"3\" name=\"dayphone2\">"
2617 " -" 2572 " -"
(...skipping 17 matching lines...) Expand all
2635 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0], 2590 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
2636 FormManager::REQUIRE_NONE, 2591 FormManager::REQUIRE_NONE,
2637 FormManager::EXTRACT_VALUE, 2592 FormManager::EXTRACT_VALUE,
2638 &form)); 2593 &form));
2639 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2594 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2640 EXPECT_EQ(GURL(frame->document().url()), form.origin); 2595 EXPECT_EQ(GURL(frame->document().url()), form.origin);
2641 EXPECT_EQ(GURL("http://cnn.com"), form.action); 2596 EXPECT_EQ(GURL("http://cnn.com"), form.action);
2642 2597
2643 const std::vector<FormField>& fields = form.fields; 2598 const std::vector<FormField>& fields = form.fields;
2644 ASSERT_EQ(6U, fields.size()); 2599 ASSERT_EQ(6U, fields.size());
2645 EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"), 2600
2646 ASCIIToUTF16("dayphone1"), 2601 FormField expected;
2647 string16(), 2602 expected.form_control_type = ASCIIToUTF16("text");
2648 ASCIIToUTF16("text"), 2603
2649 3, 2604 expected.label = ASCIIToUTF16("Phone:");
2650 false), 2605 expected.name = ASCIIToUTF16("dayphone1");
2651 fields[0]); 2606 expected.max_length = 3;
2652 EXPECT_EQ(FormField(ASCIIToUTF16("-"), 2607 SCOPED_TRACE("");
2653 ASCIIToUTF16("dayphone2"), 2608 ExpectFieldEquals(expected, fields[0]);
2654 string16(), 2609
2655 ASCIIToUTF16("text"), 2610 expected.label = ASCIIToUTF16("-");
2656 3, 2611 expected.name = ASCIIToUTF16("dayphone2");
2657 false), 2612 expected.max_length = 3;
2658 fields[1]); 2613 SCOPED_TRACE("");
2659 EXPECT_EQ(FormField(ASCIIToUTF16("-"), 2614 ExpectFieldEquals(expected, fields[1]);
2660 ASCIIToUTF16("dayphone3"), 2615
2661 string16(), 2616 expected.label = ASCIIToUTF16("-");
2662 ASCIIToUTF16("text"), 2617 expected.name = ASCIIToUTF16("dayphone3");
2663 4, 2618 expected.max_length = 4;
2664 false), 2619 SCOPED_TRACE("");
2665 fields[2]); 2620 ExpectFieldEquals(expected, fields[2]);
2666 EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"), 2621
2667 ASCIIToUTF16("dayphone4"), 2622 expected.label = ASCIIToUTF16("ext.:");
2668 string16(), 2623 expected.name = ASCIIToUTF16("dayphone4");
2669 ASCIIToUTF16("text"), 2624 expected.max_length = 5;
2670 5, 2625 SCOPED_TRACE("");
2671 false), 2626 ExpectFieldEquals(expected, fields[3]);
2672 fields[3]); 2627
2673 // When unspecified |size|, default is returned. 2628 // When unspecified |size|, default is returned.
2674 EXPECT_EQ(FormField(string16(), 2629 expected.label = string16();
2675 ASCIIToUTF16("default1"), 2630 expected.name = ASCIIToUTF16("default1");
2676 string16(), 2631 expected.max_length = WebInputElement::defaultMaxLength();
2677 ASCIIToUTF16("text"), 2632 SCOPED_TRACE("");
2678 WebInputElement::defaultMaxLength(), 2633 ExpectFieldEquals(expected, fields[4]);
2679 false), 2634
2680 fields[4]);
2681 // When invalid |size|, default is returned. 2635 // When invalid |size|, default is returned.
2682 EXPECT_EQ(FormField(string16(), 2636 expected.label = string16();
2683 ASCIIToUTF16("invalid1"), 2637 expected.name = ASCIIToUTF16("invalid1");
2684 string16(), 2638 expected.max_length = WebInputElement::defaultMaxLength();
2685 ASCIIToUTF16("text"), 2639 SCOPED_TRACE("");
2686 WebInputElement::defaultMaxLength(), 2640 ExpectFieldEquals(expected, fields[5]);
2687 false),
2688 fields[5]);
2689 } 2641 }
2690 2642
2691 // This test re-creates the experience of typing in a field then selecting a 2643 // This test re-creates the experience of typing in a field then selecting a
2692 // profile from the Autofill suggestions popup. The field that is being typed 2644 // profile from the Autofill suggestions popup. The field that is being typed
2693 // into should be filled even though it's not technically empty. 2645 // into should be filled even though it's not technically empty.
2694 TEST_F(FormManagerTest, FillFormNonEmptyField) { 2646 TEST_F(FormManagerTest, FillFormNonEmptyField) {
2695 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2647 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2696 " <INPUT type=\"text\" id=\"firstname\"/>" 2648 " <INPUT type=\"text\" id=\"firstname\"/>"
2697 " <INPUT type=\"text\" id=\"lastname\"/>" 2649 " <INPUT type=\"text\" id=\"lastname\"/>"
2698 " <INPUT type=\"text\" id=\"email\"/>" 2650 " <INPUT type=\"text\" id=\"email\"/>"
(...skipping 18 matching lines...) Expand all
2717 // Find the form that contains the input element. 2669 // Find the form that contains the input element.
2718 FormData form; 2670 FormData form;
2719 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2671 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2720 &form)); 2672 &form));
2721 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 2673 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
2722 EXPECT_EQ(GURL(web_frame->document().url()), form.origin); 2674 EXPECT_EQ(GURL(web_frame->document().url()), form.origin);
2723 EXPECT_EQ(GURL("http://buh.com"), form.action); 2675 EXPECT_EQ(GURL("http://buh.com"), form.action);
2724 2676
2725 const std::vector<FormField>& fields = form.fields; 2677 const std::vector<FormField>& fields = form.fields;
2726 ASSERT_EQ(3U, fields.size()); 2678 ASSERT_EQ(3U, fields.size());
2727 EXPECT_EQ(FormField(string16(), 2679
2728 ASCIIToUTF16("firstname"), 2680 FormField expected;
2729 string16(), 2681 expected.form_control_type = ASCIIToUTF16("text");
2730 ASCIIToUTF16("text"), 2682 expected.max_length = WebInputElement::defaultMaxLength();
2731 WebInputElement::defaultMaxLength(), 2683
2732 false), 2684 expected.name = ASCIIToUTF16("firstname");
2733 fields[0]); 2685 expected.value = ASCIIToUTF16("Wy");
2734 EXPECT_EQ(FormField(string16(), 2686 expected.is_autofilled = false;
2735 ASCIIToUTF16("lastname"), 2687 SCOPED_TRACE("");
2736 string16(), 2688 ExpectFieldEquals(expected, fields[0]);
2737 ASCIIToUTF16("text"), 2689
2738 WebInputElement::defaultMaxLength(), 2690 expected.name = ASCIIToUTF16("lastname");
2739 false), 2691 expected.value = string16();
2740 fields[1]); 2692 expected.is_autofilled = false;
2741 EXPECT_EQ(FormField(string16(), 2693 SCOPED_TRACE("");
2742 ASCIIToUTF16("email"), 2694 ExpectFieldEquals(expected, fields[1]);
2743 string16(), 2695
2744 ASCIIToUTF16("text"), 2696 expected.name = ASCIIToUTF16("email");
2745 WebInputElement::defaultMaxLength(), 2697 expected.value = string16();
2746 false), 2698 expected.is_autofilled = false;
2747 fields[2]); 2699 SCOPED_TRACE("");
2700 ExpectFieldEquals(expected, fields[2]);
2748 2701
2749 // Preview the form and verify that the cursor position has been updated. 2702 // Preview the form and verify that the cursor position has been updated.
2750 form.fields[0].value = ASCIIToUTF16("Wyatt"); 2703 form.fields[0].value = ASCIIToUTF16("Wyatt");
2751 form.fields[1].value = ASCIIToUTF16("Earp"); 2704 form.fields[1].value = ASCIIToUTF16("Earp");
2752 form.fields[2].value = ASCIIToUTF16("wyatt@example.com"); 2705 form.fields[2].value = ASCIIToUTF16("wyatt@example.com");
2753 form_manager.PreviewForm(form, input_element); 2706 form_manager.PreviewForm(form, input_element);
2754 EXPECT_EQ(2, input_element.selectionStart()); 2707 EXPECT_EQ(2, input_element.selectionStart());
2755 EXPECT_EQ(5, input_element.selectionEnd()); 2708 EXPECT_EQ(5, input_element.selectionEnd());
2756 2709
2757 // Fill the form. 2710 // Fill the form.
2758 form_manager.FillForm(form, input_element); 2711 form_manager.FillForm(form, input_element);
2759 2712
2760 // Find the newly-filled form that contains the input element. 2713 // Find the newly-filled form that contains the input element.
2761 FormData form2; 2714 FormData form2;
2762 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element, 2715 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(input_element,
2763 &form2)); 2716 &form2));
2764 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2717 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2765 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2718 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2766 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2719 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2767 2720
2768 const std::vector<FormField>& fields2 = form2.fields; 2721 const std::vector<FormField>& fields2 = form2.fields;
2769 ASSERT_EQ(3U, fields2.size()); 2722 ASSERT_EQ(3U, fields2.size());
2770 EXPECT_EQ(FormField(string16(), 2723
2771 ASCIIToUTF16("firstname"), 2724 expected.name = ASCIIToUTF16("firstname");
2772 ASCIIToUTF16("Wyatt"), 2725 expected.value = ASCIIToUTF16("Wyatt");
2773 ASCIIToUTF16("text"), 2726 expected.is_autofilled = true;
2774 WebInputElement::defaultMaxLength(), 2727 SCOPED_TRACE("");
2775 false), 2728 ExpectFieldEquals(expected, fields2[0]);
2776 fields2[0]); 2729
2777 EXPECT_EQ(FormField(string16(), 2730 expected.name = ASCIIToUTF16("lastname");
2778 ASCIIToUTF16("lastname"), 2731 expected.value = ASCIIToUTF16("Earp");
2779 ASCIIToUTF16("Earp"), 2732 expected.is_autofilled = true;
2780 ASCIIToUTF16("text"), 2733 SCOPED_TRACE("");
2781 WebInputElement::defaultMaxLength(), 2734 ExpectFieldEquals(expected, fields2[1]);
2782 false), 2735
2783 fields2[1]); 2736 expected.name = ASCIIToUTF16("email");
2784 EXPECT_EQ(FormField(string16(), 2737 expected.value = ASCIIToUTF16("wyatt@example.com");
2785 ASCIIToUTF16("email"), 2738 expected.is_autofilled = true;
2786 ASCIIToUTF16("wyatt@example.com"), 2739 SCOPED_TRACE("");
2787 ASCIIToUTF16("text"), 2740 ExpectFieldEquals(expected, fields2[2]);
2788 WebInputElement::defaultMaxLength(),
2789 false),
2790 fields2[2]);
2791 2741
2792 // Verify that the cursor position has been updated. 2742 // Verify that the cursor position has been updated.
2793 EXPECT_EQ(5, input_element.selectionStart()); 2743 EXPECT_EQ(5, input_element.selectionStart());
2794 EXPECT_EQ(5, input_element.selectionEnd()); 2744 EXPECT_EQ(5, input_element.selectionEnd());
2795 } 2745 }
2796 2746
2797 TEST_F(FormManagerTest, ClearFormWithNode) { 2747 TEST_F(FormManagerTest, ClearFormWithNode) {
2798 LoadHTML( 2748 LoadHTML(
2799 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2749 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2800 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2750 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
(...skipping 29 matching lines...) Expand all
2830 2780
2831 // Verify the form is cleared. 2781 // Verify the form is cleared.
2832 FormData form2; 2782 FormData form2;
2833 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2)); 2783 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2));
2834 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2784 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2835 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2785 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2836 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2786 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2837 2787
2838 const std::vector<FormField>& fields2 = form2.fields; 2788 const std::vector<FormField>& fields2 = form2.fields;
2839 ASSERT_EQ(4U, fields2.size()); 2789 ASSERT_EQ(4U, fields2.size());
2840 EXPECT_TRUE(fields2[0].StrictlyEqualsHack( 2790
2841 FormField(string16(), 2791 FormField expected;
2842 ASCIIToUTF16("firstname"), 2792 expected.form_control_type = ASCIIToUTF16("text");
2843 string16(), 2793 expected.max_length = WebInputElement::defaultMaxLength();
2844 ASCIIToUTF16("text"), 2794
2845 WebInputElement::defaultMaxLength(), 2795 expected.name = ASCIIToUTF16("firstname");
2846 false))); 2796 expected.value = string16();
2847 EXPECT_TRUE(fields2[1].StrictlyEqualsHack( 2797 SCOPED_TRACE("");
2848 FormField(string16(), 2798 ExpectFieldEquals(expected, fields2[0]);
2849 ASCIIToUTF16("lastname"), 2799
2850 string16(), 2800 expected.name = ASCIIToUTF16("lastname");
2851 ASCIIToUTF16("text"), 2801 expected.value = string16();
2852 WebInputElement::defaultMaxLength(), 2802 SCOPED_TRACE("");
2853 false))); 2803 ExpectFieldEquals(expected, fields2[1]);
2854 EXPECT_TRUE(fields2[2].StrictlyEqualsHack( 2804
2855 FormField(string16(), 2805 expected.name = ASCIIToUTF16("noAC");
2856 ASCIIToUTF16("noAC"), 2806 expected.value = string16();
2857 string16(), 2807 SCOPED_TRACE("");
2858 ASCIIToUTF16("text"), 2808 ExpectFieldEquals(expected, fields2[2]);
2859 WebInputElement::defaultMaxLength(), 2809
2860 false))); 2810 expected.name = ASCIIToUTF16("notenabled");
2861 EXPECT_TRUE(fields2[3].StrictlyEqualsHack( 2811 expected.value = ASCIIToUTF16("no clear");
2862 FormField(string16(), 2812 SCOPED_TRACE("");
2863 ASCIIToUTF16("notenabled"), 2813 ExpectFieldEquals(expected, fields2[3]);
2864 ASCIIToUTF16("no clear"),
2865 ASCIIToUTF16("text"),
2866 WebInputElement::defaultMaxLength(),
2867 false)));
2868 2814
2869 // Verify that the cursor position has been updated. 2815 // Verify that the cursor position has been updated.
2870 EXPECT_EQ(0, firstname.selectionStart()); 2816 EXPECT_EQ(0, firstname.selectionStart());
2871 EXPECT_EQ(0, firstname.selectionEnd()); 2817 EXPECT_EQ(0, firstname.selectionEnd());
2872 } 2818 }
2873 2819
2874 TEST_F(FormManagerTest, ClearFormWithNodeContainingSelectOne) { 2820 TEST_F(FormManagerTest, ClearFormWithNodeContainingSelectOne) {
2875 LoadHTML( 2821 LoadHTML(
2876 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2822 "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2877 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2823 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
2911 2857
2912 // Verify the form is cleared. 2858 // Verify the form is cleared.
2913 FormData form2; 2859 FormData form2;
2914 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2)); 2860 EXPECT_TRUE(form_manager.FindFormWithFormControlElement(firstname, &form2));
2915 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name); 2861 EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
2916 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin); 2862 EXPECT_EQ(GURL(web_frame->document().url()), form2.origin);
2917 EXPECT_EQ(GURL("http://buh.com"), form2.action); 2863 EXPECT_EQ(GURL("http://buh.com"), form2.action);
2918 2864
2919 const std::vector<FormField>& fields2 = form2.fields; 2865 const std::vector<FormField>& fields2 = form2.fields;
2920 ASSERT_EQ(3U, fields2.size()); 2866 ASSERT_EQ(3U, fields2.size());
2921 EXPECT_TRUE(fields2[0].StrictlyEqualsHack( 2867
2922 FormField(string16(), 2868 FormField expected;
2923 ASCIIToUTF16("firstname"), 2869
2924 string16(), 2870 expected.name = ASCIIToUTF16("firstname");
2925 ASCIIToUTF16("text"), 2871 expected.value = string16();
2926 WebInputElement::defaultMaxLength(), 2872 expected.form_control_type = ASCIIToUTF16("text");
2927 false))); 2873 expected.max_length = WebInputElement::defaultMaxLength();
2928 EXPECT_TRUE(fields2[1].StrictlyEqualsHack( 2874 SCOPED_TRACE("");
2929 FormField(string16(), 2875 ExpectFieldEquals(expected, fields2[0]);
2930 ASCIIToUTF16("lastname"), 2876
2931 string16(), 2877 expected.name = ASCIIToUTF16("lastname");
2932 ASCIIToUTF16("text"), 2878 expected.value = string16();
2933 WebInputElement::defaultMaxLength(), 2879 expected.form_control_type = ASCIIToUTF16("text");
2934 false))); 2880 expected.max_length = WebInputElement::defaultMaxLength();
2935 EXPECT_TRUE(fields2[2].StrictlyEqualsHack( 2881 SCOPED_TRACE("");
2936 FormField(string16(), 2882 ExpectFieldEquals(expected, fields2[1]);
2937 ASCIIToUTF16("state"), 2883
2938 ASCIIToUTF16("?"), 2884 expected.name = ASCIIToUTF16("state");
2939 ASCIIToUTF16("select-one"), 2885 expected.value = ASCIIToUTF16("?");
2940 0, 2886 expected.form_control_type = ASCIIToUTF16("select-one");
2941 false))); 2887 expected.max_length = 0;
2888 SCOPED_TRACE("");
2889 ExpectFieldEquals(expected, fields2[2]);
2942 2890
2943 // Verify that the cursor position has been updated. 2891 // Verify that the cursor position has been updated.
2944 EXPECT_EQ(0, firstname.selectionStart()); 2892 EXPECT_EQ(0, firstname.selectionStart());
2945 EXPECT_EQ(0, firstname.selectionEnd()); 2893 EXPECT_EQ(0, firstname.selectionEnd());
2946 } 2894 }
2947 2895
2948 TEST_F(FormManagerTest, ClearPreviewedFormWithNode) { 2896 TEST_F(FormManagerTest, ClearPreviewedFormWithNode) {
2949 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">" 2897 LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
2950 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>" 2898 " <INPUT type=\"text\" id=\"firstname\" value=\"Wyatt\"/>"
2951 " <INPUT type=\"text\" id=\"lastname\"/>" 2899 " <INPUT type=\"text\" id=\"lastname\"/>"
(...skipping 309 matching lines...) Expand 10 before | Expand all | Expand 10 after
3261 forms[0], FormManager::REQUIRE_NONE, 3209 forms[0], FormManager::REQUIRE_NONE,
3262 static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE | 3210 static_cast<FormManager::ExtractMask>(FormManager::EXTRACT_VALUE |
3263 FormManager::EXTRACT_OPTION_TEXT), 3211 FormManager::EXTRACT_OPTION_TEXT),
3264 &form)); 3212 &form));
3265 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 3213 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
3266 EXPECT_EQ(GURL(frame->document().url()), form.origin); 3214 EXPECT_EQ(GURL(frame->document().url()), form.origin);
3267 EXPECT_EQ(GURL("http://cnn.com"), form.action); 3215 EXPECT_EQ(GURL("http://cnn.com"), form.action);
3268 3216
3269 const std::vector<FormField>& fields = form.fields; 3217 const std::vector<FormField>& fields = form.fields;
3270 ASSERT_EQ(3U, fields.size()); 3218 ASSERT_EQ(3U, fields.size());
3271 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 3219
3272 FormField(string16(), 3220 FormField expected;
3273 ASCIIToUTF16("firstname"), 3221
3274 ASCIIToUTF16("John"), 3222 expected.name = ASCIIToUTF16("firstname");
3275 ASCIIToUTF16("text"), 3223 expected.value = ASCIIToUTF16("John");
3276 WebInputElement::defaultMaxLength(), 3224 expected.form_control_type = ASCIIToUTF16("text");
3277 false))); 3225 expected.max_length = WebInputElement::defaultMaxLength();
3278 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 3226 SCOPED_TRACE("");
3279 FormField(string16(), 3227 ExpectFieldEquals(expected, fields[0]);
3280 ASCIIToUTF16("lastname"), 3228
3281 ASCIIToUTF16("Smith"), 3229 expected.name = ASCIIToUTF16("lastname");
3282 ASCIIToUTF16("text"), 3230 expected.value = ASCIIToUTF16("Smith");
3283 WebInputElement::defaultMaxLength(), 3231 expected.form_control_type = ASCIIToUTF16("text");
3284 false))); 3232 expected.max_length = WebInputElement::defaultMaxLength();
3285 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 3233 SCOPED_TRACE("");
3286 FormField(string16(), 3234 ExpectFieldEquals(expected, fields[1]);
3287 ASCIIToUTF16("country"), 3235
3288 ASCIIToUTF16("Albania"), 3236 expected.name = ASCIIToUTF16("country");
3289 ASCIIToUTF16("select-one"), 3237 expected.value = ASCIIToUTF16("Albania");
3290 0, 3238 expected.form_control_type = ASCIIToUTF16("select-one");
3291 false))); 3239 expected.max_length = 0;
3240 SCOPED_TRACE("");
3241 ExpectFieldEquals(expected, fields[2]);
3292 3242
3293 form.fields.clear(); 3243 form.fields.clear();
3294 // Extract the country select-one value as value. 3244 // Extract the country select-one value as value.
3295 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0], 3245 EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
3296 FormManager::REQUIRE_NONE, 3246 FormManager::REQUIRE_NONE,
3297 FormManager::EXTRACT_VALUE, 3247 FormManager::EXTRACT_VALUE,
3298 &form)); 3248 &form));
3299 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name); 3249 EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
3300 EXPECT_EQ(GURL(frame->document().url()), form.origin); 3250 EXPECT_EQ(GURL(frame->document().url()), form.origin);
3301 EXPECT_EQ(GURL("http://cnn.com"), form.action); 3251 EXPECT_EQ(GURL("http://cnn.com"), form.action);
3302 3252
3303 ASSERT_EQ(3U, fields.size()); 3253 ASSERT_EQ(3U, fields.size());
3304 EXPECT_TRUE(fields[0].StrictlyEqualsHack( 3254
3305 FormField(string16(), 3255 expected.name = ASCIIToUTF16("firstname");
3306 ASCIIToUTF16("firstname"), 3256 expected.value = ASCIIToUTF16("John");
3307 ASCIIToUTF16("John"), 3257 expected.form_control_type = ASCIIToUTF16("text");
3308 ASCIIToUTF16("text"), 3258 expected.max_length = WebInputElement::defaultMaxLength();
3309 WebInputElement::defaultMaxLength(), 3259 SCOPED_TRACE("");
3310 false))); 3260 ExpectFieldEquals(expected, fields[0]);
3311 EXPECT_TRUE(fields[1].StrictlyEqualsHack( 3261
3312 FormField(string16(), 3262 expected.name = ASCIIToUTF16("lastname");
3313 ASCIIToUTF16("lastname"), 3263 expected.value = ASCIIToUTF16("Smith");
3314 ASCIIToUTF16("Smith"), 3264 expected.form_control_type = ASCIIToUTF16("text");
3315 ASCIIToUTF16("text"), 3265 expected.max_length = WebInputElement::defaultMaxLength();
3316 WebInputElement::defaultMaxLength(), 3266 SCOPED_TRACE("");
3317 false))); 3267 ExpectFieldEquals(expected, fields[1]);
3318 EXPECT_TRUE(fields[2].StrictlyEqualsHack( 3268
3319 FormField(string16(), 3269 expected.name = ASCIIToUTF16("country");
3320 ASCIIToUTF16("country"), 3270 expected.value = ASCIIToUTF16("AL");
3321 ASCIIToUTF16("AL"), 3271 expected.form_control_type = ASCIIToUTF16("select-one");
3322 ASCIIToUTF16("select-one"), 3272 expected.max_length = 0;
3323 0, 3273 SCOPED_TRACE("");
3324 false))); 3274 ExpectFieldEquals(expected, fields[2]);
3325 } 3275 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698