Pull in a named constant from WebKit

chrome/renderer/autofill/form_manager_browsertest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/autofill/form_manager.h"
@@ skipping 20 matching lines @@
 using WebKit::WebSelectElement;
 using WebKit::WebNode;
 using WebKit::WebString;
 using WebKit::WebVector;
 
 using autofill::FormManager;
 
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 
-namespace {
-
-// TODO(isherman): Pull this as a named constant from WebKit
-const int kDefaultMaxLength = 0x80000;
-
-}  // namespace
-
 class FormManagerTest : public RenderViewTest {
  public:
   FormManagerTest() : RenderViewTest() {}
   virtual ~FormManagerTest() {}
 
   void ExpectLabels(const char* html,
                     const std::vector<string16>& labels,
                     const std::vector<string16>& names,
                     const std::vector<string16>& values) {
     ASSERT_EQ(labels.size(), names.size());
@@ skipping 17 matching lines @@
     EXPECT_EQ(GURL(web_frame->url()), form.origin);
     EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
     const std::vector<FormField>& fields = form.fields;
     ASSERT_EQ(labels.size(), fields.size());
     for (size_t i = 0; i < labels.size(); ++i) {
       FormField expected = FormField(labels[i],
                                      names[i],
                                      values[i],
                                      ASCIIToUTF16("text"),
-                                     kDefaultMaxLength,
+                                     kDefaultMaxLength(),
                                      false);
       EXPECT_TRUE(fields[i].StrictlyEqualsHack(expected))
           << "Expected \"" << expected << "\", got \"" << fields[i] << "\"";
     }
   }
 
   void ExpectJohnSmithLabels(const char* html) {
     std::vector<string16> labels, names, values;
 
     labels.push_back(ASCIIToUTF16("First name:"));
     names.push_back(ASCIIToUTF16("firstname"));
     values.push_back(ASCIIToUTF16("John"));
 
     labels.push_back(ASCIIToUTF16("Last name:"));
     names.push_back(ASCIIToUTF16("lastname"));
     values.push_back(ASCIIToUTF16("Smith"));
 
     labels.push_back(ASCIIToUTF16("Email:"));
     names.push_back(ASCIIToUTF16("email"));
     values.push_back(ASCIIToUTF16("john@example.com"));
 
     ExpectLabels(html, labels, names, values);
   }
 
+  // Declared as a function rather than a constant to make sure that
+  // initialization order works out correctly.
+  static int kDefaultMaxLength() {

[dhollowa, 2011/02/11 17:14:32]

Actually, let's just get rid of this function and call the WebKit version
directly.  No need for a wrapper.

[Ilya Sherman, 2011/02/11 21:34:00]

Done.

+    return WebInputElement::defaultMaxLength();
+  }
+
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FormManagerTest);
 };
 
 // We should be able to extract a normal text field.
 TEST_F(FormManagerTest, WebFormControlElementToFormField) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result1;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_NONE,
                                                 &result1);
   EXPECT_TRUE(result1.StrictlyEqualsHack(FormField(string16(),
                                                    ASCIIToUTF16("element"),
                                                    string16(),
                                                    ASCIIToUTF16("text"),
-                                                   kDefaultMaxLength,
+                                                   kDefaultMaxLength(),
                                                    false)));
   FormField result2;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result2);
   EXPECT_TRUE(result2.StrictlyEqualsHack(FormField(string16(),
                                                    ASCIIToUTF16("element"),
                                                    ASCIIToUTF16("value"),
                                                    ASCIIToUTF16("text"),
-                                                   kDefaultMaxLength,
+                                                   kDefaultMaxLength(),
                                                    false)));
 }
 
 // We should be able to extract a text field with autocomplete="off".
 TEST_F(FormManagerTest, WebFormControlElementToFormFieldAutocompleteOff) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
            "       autocomplete=\"off\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
 
   WebElement web_element = frame->document().getElementById("element");
   WebFormControlElement element = web_element.to<WebFormControlElement>();
   FormField result;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
   EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
                                                   ASCIIToUTF16("element"),
                                                   ASCIIToUTF16("value"),
                                                   ASCIIToUTF16("text"),
-                                                  kDefaultMaxLength,
+                                                  kDefaultMaxLength(),
                                                   false)));
 }
 
 // We should be able to extract a text field with maxlength specified.
 TEST_F(FormManagerTest, WebFormControlElementToFormFieldMaxLength) {
   LoadHTML("<INPUT type=\"text\" id=\"element\" value=\"value\""
            "       maxlength=\"5\"/>");
 
   WebFrame* frame = GetMainFrame();
   ASSERT_NE(static_cast<WebFrame*>(NULL), frame);
@@ skipping 23 matching lines @@
   WebInputElement element = web_element.to<WebInputElement>();
   element.setAutofilled(true);
   FormField result;
   FormManager::WebFormControlElementToFormField(element,
                                                 FormManager::EXTRACT_VALUE,
                                                 &result);
   EXPECT_TRUE(result.StrictlyEqualsHack(FormField(string16(),
                                                   ASCIIToUTF16("element"),
                                                   ASCIIToUTF16("value"),
                                                   ASCIIToUTF16("text"),
-                                                  kDefaultMaxLength,
+                                                  kDefaultMaxLength(),
                                                   true)));
 }
 
 // We should be able to extract a <select> field.
 TEST_F(FormManagerTest, WebFormControlElementToFormFieldSelect) {
   LoadHTML("<SELECT id=\"element\"/>"
            "  <OPTION value=\"CA\">California</OPTION>"
            "  <OPTION value=\"TX\">Texas</OPTION>"
            "</SELECT>");
 
@@ skipping 144 matching lines @@
   EXPECT_EQ(GURL(frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 ASCIIToUTF16("John"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 ASCIIToUTF16("Smith"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("state"),
                 ASCIIToUTF16("CA"),
                 ASCIIToUTF16("select-one"),
                 0,
                 false)));
 }
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("John"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Smith"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("john@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 }
 
 TEST_F(FormManagerTest, ExtractMultipleForms) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
@@ skipping 20 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("John"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Smith"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("john@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 
   // Second form.
   const FormData& form2 = forms[1];
   EXPECT_EQ(ASCIIToUTF16("TestForm2"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://zoo.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("Jack"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Adams"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("jack@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 }
 
 // We should not extract a form if it has too few fillable fields.
 TEST_F(FormManagerTest, ExtractFormsTooFewFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
@@ skipping 62 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://abc.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("middlename"),
                       ASCIIToUTF16("Jack"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Smith"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("john@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 }
 
 TEST_F(FormManagerTest, GetFormsElementsEnabled) {
   // The firstname element is not enabled due to disabled being set.
   LoadHTML("<FORM name=\"TestForm\" action=\"http://xyz.com\" method=\"post\">"
            "  <INPUT disabled type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"middlename\" value=\"Jack\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
@@ skipping 15 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://xyz.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("middlename"),
                       ASCIIToUTF16("Jack"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Smith"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("jack@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 }
 
 TEST_F(FormManagerTest, FindForm) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\" value=\"John\"/>"
            "  <INPUT type=\"text\" id=\"lastname\" value=\"Smith\"/>"
            "  <INPUT type=\"text\" id=\"email\" value=\"john@example.com\"/>"
            "  <INPUT type=\"submit\" name=\"reply-send\" value=\"Send\"/>"
@@ skipping 21 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("John"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Smith"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("john@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 }
 
 TEST_F(FormManagerTest, FillForm) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
            "  <INPUT type=\"hidden\" id=\"imhidden\"/>"
            "  <INPUT type=\"text\" id=\"notempty\" value=\"Hi\"/>"
@@ skipping 24 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(5U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("notempty"),
                       ASCIIToUTF16("Hi"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("noautocomplete"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[3]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("notenabled"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[4]);
 
   // Fill the form.
   form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
   form.fields[1].set_value(ASCIIToUTF16("Earp"));
   form.fields[2].set_value(ASCIIToUTF16("Alpha"));
   form.fields[3].set_value(ASCIIToUTF16("Beta"));
   form.fields[4].set_value(ASCIIToUTF16("Gamma"));
   EXPECT_TRUE(form_manager.FillForm(form, input_element));
@@ skipping 63 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(5U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("notempty"),
                       ASCIIToUTF16("Hi"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("noautocomplete"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[3]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("notenabled"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[4]);
 
   // Preview the form.
   form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
   form.fields[1].set_value(ASCIIToUTF16("Earp"));
   form.fields[2].set_value(ASCIIToUTF16("Alpha"));
   form.fields[3].set_value(ASCIIToUTF16("Beta"));
   form.fields[4].set_value(ASCIIToUTF16("Gamma"));
   EXPECT_TRUE(form_manager.PreviewForm(form, input_element));
@@ skipping 638 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 
   // Fill the form.
   form.fields[0].set_value(ASCIIToUTF16("Brother"));
   form.fields[1].set_value(ASCIIToUTF16("Jonathan"));
   form.fields[2].set_value(ASCIIToUTF16("brotherj@example.com"));
   EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
       input_element, FormManager::REQUIRE_NONE, &form2));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 ASCIIToUTF16("Brother"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 ASCIIToUTF16("Jonathan"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("email"),
                 ASCIIToUTF16("brotherj@example.com"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
 }
 
 // This test sends a FormData object to FillForm with more fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormMoreFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
@@ skipping 19 matching lines @@
   //  middlename
   //  second
   //  lastname
   //  postfix
   FormData* form = &forms[0];
 
   FormField field1(string16(),
                    ASCIIToUTF16("prefix"),
                    string16(),
                    ASCIIToUTF16("text"),
-                   kDefaultMaxLength,
+                   kDefaultMaxLength(),
                    false);
   form->fields.insert(form->fields.begin(), field1);
 
   FormField field2(string16(),
                    ASCIIToUTF16("hidden"),
                    string16(),
                    ASCIIToUTF16("text"),
-                   kDefaultMaxLength,
+                   kDefaultMaxLength(),
                    false);
   form->fields.insert(form->fields.begin() + 2, field2);
 
   FormField field3(string16(),
                    ASCIIToUTF16("second"),
                    string16(),
                    ASCIIToUTF16("text"),
-                   kDefaultMaxLength,
+                   kDefaultMaxLength(),
                    false);
   form->fields.insert(form->fields.begin() + 4, field3);
 
   FormField field4(string16(),
                    ASCIIToUTF16("postfix"),
                    string16(),
                    ASCIIToUTF16("text"),
-                   kDefaultMaxLength,
+                   kDefaultMaxLength(),
                    false);
   form->fields.insert(form->fields.begin() + 6, field4);
 
   // Fill the form.
   form->fields[0].set_value(ASCIIToUTF16("Alpha"));
   form->fields[1].set_value(ASCIIToUTF16("Brother"));
   form->fields[2].set_value(ASCIIToUTF16("Abracadabra"));
   form->fields[3].set_value(ASCIIToUTF16("Joseph"));
   form->fields[4].set_value(ASCIIToUTF16("Beta"));
   form->fields[5].set_value(ASCIIToUTF16("Jonathan"));
@@ skipping 11 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields = form2.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("firstname"),
                                                      ASCIIToUTF16("Brother"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("middlename"),
                                                      ASCIIToUTF16("Joseph"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("lastname"),
                                                      ASCIIToUTF16("Jonathan"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
 }
 
 // This test sends a FormData object to FillForm with fewer fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormFewerFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"prefix\"/>"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
@@ skipping 43 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields = form2.fields;
   ASSERT_EQ(7U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("prefix"),
                                                      string16(),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("firstname"),
                                                      ASCIIToUTF16("Brother"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("hidden"),
                                                      string16(),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("middlename"),
                                                      ASCIIToUTF16("Joseph"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[4].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("second"),
                                                      string16(),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[5].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("lastname"),
                                                      ASCIIToUTF16("Jonathan"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[6].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("postfix"),
                                                      string16(),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
 }
 
 // This test sends a FormData object to FillForm with a field changed from
 // those in the cached WebFormElement.  In this case, we only fill out the
 // fields that match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormChangedFormDataFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
@@ skipping 40 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields = form2.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
                                            ASCIIToUTF16("firstname"),
                                            ASCIIToUTF16("Brother"),
                                            ASCIIToUTF16("text"),
-                                           kDefaultMaxLength,
+                                           kDefaultMaxLength(),
                                            false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
                                            ASCIIToUTF16("middlename"),
                                            string16(),
                                            ASCIIToUTF16("text"),
-                                           kDefaultMaxLength,
+                                           kDefaultMaxLength(),
                                            false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
                                            ASCIIToUTF16("lastname"),
                                            ASCIIToUTF16("Jonathan"),
                                            ASCIIToUTF16("text"),
-                                           kDefaultMaxLength,
+                                           kDefaultMaxLength(),
                                            false)));
 }
 
 // This test sends a FormData object to FillForm with fewer fields than are in
 // the cached WebFormElement.  In this case, we only fill out the fields that
 // match between the FormData object and the WebFormElement.
 TEST_F(FormManagerTest, FillFormExtraFieldInCache) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
@@ skipping 37 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields = form2.fields;
   ASSERT_EQ(4U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("firstname"),
                                                      ASCIIToUTF16("Brother"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("middlename"),
                                                      ASCIIToUTF16("Joseph"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("lastname"),
                                                      ASCIIToUTF16("Jonathan"),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
   EXPECT_TRUE(fields[3].StrictlyEqualsHack(FormField(string16(),
                                                      ASCIIToUTF16("postfix"),
                                                      string16(),
                                                      ASCIIToUTF16("text"),
-                                                     kDefaultMaxLength,
+                                                     kDefaultMaxLength(),
                                                      false)));
 }
 
 TEST_F(FormManagerTest, FillFormEmptyName) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
            "  <INPUT type=\"text\" id=\"email\"/>"
            "  <INPUT type=\"submit\" value=\"Send\"/>"
            "</FORM>");
@@ skipping 20 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 
   // Fill the form.
   form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
   form.fields[1].set_value(ASCIIToUTF16("Earp"));
   form.fields[2].set_value(ASCIIToUTF16("wyatt@example.com"));
   EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
       input_element, FormManager::REQUIRE_NONE, &form2));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("Wyatt"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Earp"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("wyatt@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[2]);
 }
 
 TEST_F(FormManagerTest, FillFormEmptyFormNames) {
   LoadHTML("<FORM action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
            "  <INPUT type=\"text\" id=\"middlename\"/>"
            "  <INPUT type=\"text\" id=\"lastname\"/>"
            "  <INPUT type=\"submit\" value=\"Send\"/>"
@@ skipping 27 matching lines @@
   EXPECT_EQ(string16(), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://abc.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("apple"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("banana"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("cantelope"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 
   // Fill the form.
   form.fields[0].set_value(ASCIIToUTF16("Red"));
   form.fields[1].set_value(ASCIIToUTF16("Yellow"));
   form.fields[2].set_value(ASCIIToUTF16("Also Yellow"));
   EXPECT_TRUE(form_manager.FillForm(form, WebNode()));
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
       input_element, FormManager::REQUIRE_NONE, &form2));
   EXPECT_EQ(string16(), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://abc.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("apple"),
                       ASCIIToUTF16("Red"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("banana"),
                       ASCIIToUTF16("Yellow"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("cantelope"),
                       ASCIIToUTF16("Also Yellow"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[2]);
 }
 
 TEST_F(FormManagerTest, ThreePartPhone) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  Phone:"
            "  <input type=\"text\" name=\"dayphone1\">"
            "  -"
            "  <input type=\"text\" name=\"dayphone2\">"
@@ skipping 20 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(4U, fields.size());
   EXPECT_EQ(FormField(ASCIIToUTF16("Phone:"),
                       ASCIIToUTF16("dayphone1"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(ASCIIToUTF16("-"),
                       ASCIIToUTF16("dayphone2"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(ASCIIToUTF16("-"),
                       ASCIIToUTF16("dayphone3"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
   EXPECT_EQ(FormField(ASCIIToUTF16("ext.:"),
                       ASCIIToUTF16("dayphone4"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[3]);
 }
 
 
 TEST_F(FormManagerTest, MaxLengthFields) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://cnn.com\" method=\"post\">"
            "  Phone:"
            "  <input type=\"text\" maxlength=\"3\" name=\"dayphone1\">"
            "  -"
@@ skipping 52 matching lines @@
                       string16(),
                       ASCIIToUTF16("text"),
                       5,
                       false),
             fields[3]);
   // When unspecified |size|, default is returned.
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("default1"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[4]);
   // When invalid |size|, default is returned.
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("invalid1"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[5]);
 }
 
 // This test re-creates the experience of typing in a field then selecting a
 // profile from the AutoFill suggestions popup.  The field that is being typed
 // into should be filled even though it's not technically empty.
 TEST_F(FormManagerTest, FillFormNonEmptyField) {
   LoadHTML("<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
            "  <INPUT type=\"text\" id=\"firstname\"/>"
@@ skipping 27 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(web_frame->url()), form.origin);
   EXPECT_EQ(GURL("http://buh.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       string16(),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields[2]);
 
   // Fill the form.
   form.fields[0].set_value(ASCIIToUTF16("Wyatt"));
   form.fields[1].set_value(ASCIIToUTF16("Earp"));
   form.fields[2].set_value(ASCIIToUTF16("wyatt@example.com"));
   EXPECT_TRUE(form_manager.FillForm(form, input_element));
 
   // Find the newly-filled form that contains the input element.
   FormData form2;
   EXPECT_TRUE(form_manager.FindFormWithFormControlElement(
       input_element, FormManager::REQUIRE_NONE, &form2));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form2.name);
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("firstname"),
                       ASCIIToUTF16("Wyatt"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[0]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("lastname"),
                       ASCIIToUTF16("Earp"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[1]);
   EXPECT_EQ(FormField(string16(),
                       ASCIIToUTF16("email"),
                       ASCIIToUTF16("wyatt@example.com"),
                       ASCIIToUTF16("text"),
-                      kDefaultMaxLength,
+                      kDefaultMaxLength(),
                       false),
             fields2[2]);
 
   // Verify that the cursor position has been updated.
   EXPECT_EQ(5, input_element.selectionStart());
   EXPECT_EQ(5, input_element.selectionEnd());
 }
 
 TEST_F(FormManagerTest, ClearFormWithNode) {
   LoadHTML(
@@ skipping 40 matching lines @@
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(4U, fields2.size());
   EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 string16(),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 string16(),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("noAC"),
                 string16(),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[3].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("notenabled"),
                 ASCIIToUTF16("no clear"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
 
   // Verify that the cursor position has been updated.
   EXPECT_EQ(0, firstname.selectionStart());
   EXPECT_EQ(0, firstname.selectionEnd());
 }
 
 TEST_F(FormManagerTest, ClearFormWithNodeContainingSelectOne) {
   LoadHTML(
       "<FORM name=\"TestForm\" action=\"http://buh.com\" method=\"post\">"
@@ skipping 43 matching lines @@
   EXPECT_EQ(GURL(web_frame->url()), form2.origin);
   EXPECT_EQ(GURL("http://buh.com"), form2.action);
 
   const std::vector<FormField>& fields2 = form2.fields;
   ASSERT_EQ(3U, fields2.size());
   EXPECT_TRUE(fields2[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 string16(),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 string16(),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields2[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("state"),
                 ASCIIToUTF16("?"),
                 ASCIIToUTF16("select-one"),
                 0,
                 false)));
 
   // Verify that the cursor position has been updated.
@@ skipping 302 matching lines @@
   EXPECT_EQ(GURL(frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   const std::vector<FormField>& fields = form.fields;
   ASSERT_EQ(3U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 ASCIIToUTF16("John"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 ASCIIToUTF16("Smith"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("country"),
                 ASCIIToUTF16("Albania"),
                 ASCIIToUTF16("select-one"),
                 0,
                 false)));
 
   form.fields.clear();
   // Extract the country select-one value as value.
   EXPECT_TRUE(FormManager::WebFormElementToFormData(forms[0],
                                                     FormManager::REQUIRE_NONE,
                                                     FormManager::EXTRACT_VALUE,
                                                     &form));
   EXPECT_EQ(ASCIIToUTF16("TestForm"), form.name);
   EXPECT_EQ(GURL(frame->url()), form.origin);
   EXPECT_EQ(GURL("http://cnn.com"), form.action);
 
   ASSERT_EQ(3U, fields.size());
   EXPECT_TRUE(fields[0].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("firstname"),
                 ASCIIToUTF16("John"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[1].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("lastname"),
                 ASCIIToUTF16("Smith"),
                 ASCIIToUTF16("text"),
-                kDefaultMaxLength,
+                kDefaultMaxLength(),
                 false)));
   EXPECT_TRUE(fields[2].StrictlyEqualsHack(
       FormField(string16(),
                 ASCIIToUTF16("country"),
                 ASCIIToUTF16("AL"),
                 ASCIIToUTF16("select-one"),
                 0,
                 false)));
 }