Convert autocomplete attribute values to constants

components/autofill/content/renderer/password_form_conversion_utils.cc

 // Copyright 2013 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 "components/autofill/content/renderer/password_form_conversion_utils.h"
 
 #include <vector>
 
 #include "base/i18n/case_conversion.h"
 #include "base/lazy_instance.h"
@@ skipping 40 matching lines @@
 // LAYOUT_LOGIN_AND_SIGNUP is classified by NPN+P.*. This corresponds to a form
 // which starts with a login section (NP) and continues with a sign-up section
 // (N+P.*). The aim is to distinguish such forms from change password-forms
 // (N*PPP?.*) and forms which use password fields to store private but
 // non-password data (could look like, e.g., PN+P.*).
 const char kLoginAndSignupRegex[] =
     "NP"   // Login section.
     "N+P"  // Sign-up section.
     ".*";  // Anything beyond that.
 
+const char kAutocompleteUsername[] = "username";
+const char kAutocompleteCurrentPassword[] = "current-password";
+const char kAutocompleteNewPassword[] = "new-password";
+
 struct LoginAndSignupLazyInstanceTraits
     : public base::DefaultLazyInstanceTraits<icu::RegexMatcher> {
   static icu::RegexMatcher* New(void* instance) {
     const icu::UnicodeString icu_pattern(kLoginAndSignupRegex);
 
     UErrorCode status = U_ZERO_ERROR;
     // Use placement new to initialize the instance in the preallocated space.
     // The "(instance)" is very important to force POD type initialization.
     scoped_ptr<icu::RegexMatcher> matcher(new (instance) icu::RegexMatcher(
         icu_pattern, UREGEX_CASE_INSENSITIVE, status));
@@ skipping 41 matching lines @@
                              WebInputElement* current_password,
                              WebInputElement* new_password) {
   DCHECK(current_password && current_password->isNull());
   DCHECK(new_password && new_password->isNull());
 
   // First, look for elements marked with either autocomplete='current-password'
   // or 'new-password' -- if we find any, take the hint, and treat the first of
   // each kind as the element we are looking for.
   for (std::vector<WebInputElement>::const_iterator it = passwords.begin();
        it != passwords.end(); it++) {
-    if (HasAutocompleteAttributeValue(*it, "current-password") &&
+    if (HasAutocompleteAttributeValue(*it, kAutocompleteCurrentPassword) &&
         current_password->isNull()) {
       *current_password = *it;
-    } else if (HasAutocompleteAttributeValue(*it, "new-password") &&
+    } else if (HasAutocompleteAttributeValue(*it, kAutocompleteNewPassword) &&
         new_password->isNull()) {
       *new_password = *it;
     }
   }
 
   // If we have seen an element with either of autocomplete attributes above,
   // take that as a signal that the page author must have intentionally left the
   // rest of the password fields unmarked. Perhaps they are used for other
   // purposes, e.g., PINs, OTPs, and the like. So we skip all the heuristics we
   // normally do, and ignore the rest of the password fields.
@@ skipping 146 matching lines @@
     // keyboard and bypassing the password field value (see
     // http://crbug.com/475488). There is nothing Chrome can do to fill
     // passwords for now. Continue processing in case when the password field
     // was made readonly by JavaScript before submission. We can do this by
     // checking whether password element was updated not from JavaScript.
     if (input_element->isPasswordField() &&
         (!input_element->isReadOnly() ||
          (nonscript_modified_values &&
           nonscript_modified_values->find(*input_element) !=
               nonscript_modified_values->end()) ||
-         HasAutocompleteAttributeValue(*input_element, "current-password") ||
-         HasAutocompleteAttributeValue(*input_element, "new-password"))) {
+         HasAutocompleteAttributeValue(*input_element,
+                                       kAutocompleteCurrentPassword) ||
+         HasAutocompleteAttributeValue(*input_element,
+                                       kAutocompleteNewPassword))) {
       passwords.push_back(*input_element);
       // If we have not yet considered any element to be the username so far,
       // provisionally select the input element just before the first password
       // element to be the username. This choice will be overruled if we later
       // find an element with autocomplete='username'.
       if (username_element.isNull() && !latest_input_element.isNull()) {
         username_element = latest_input_element;
         // Remove the selected username from other_possible_usernames.
         if (!latest_input_element.value().isEmpty()) {
           DCHECK(!other_possible_usernames.empty());
           DCHECK_EQ(base::string16(latest_input_element.value()),
                     other_possible_usernames.back());
           other_possible_usernames.pop_back();
         }
       }
     }
 
     // Various input types such as text, url, email can be a username field.
     if (input_element->isTextField() && !input_element->isPasswordField()) {
-      if (HasAutocompleteAttributeValue(*input_element, "username")) {
+      if (HasAutocompleteAttributeValue(*input_element,
+                                        kAutocompleteUsername)) {
         if (password_form->username_marked_by_site) {
           // A second or subsequent element marked with autocomplete='username'.
           // This makes us less confident that we have understood the form. We
           // will stick to our choice that the first such element was the real
           // username, but will start collecting other_possible_usernames from
           // the extra elements marked with autocomplete='username'. Note that
           // unlike username_element, other_possible_usernames is used only for
           // autofill, not for form identification, and blank autofill entries
           // are not useful, so we do not collect empty strings.
           if (!input_element->value().isEmpty())
@@ skipping 94 matching lines @@
     if (nonscript_modified_values != nullptr) {
       auto password_iterator = nonscript_modified_values->find(password);
       if (password_iterator != nonscript_modified_values->end())
         password_value = password_iterator->second;
     }
     password_form->password_value = password_value;
   }
   if (!new_password.isNull()) {
     password_form->new_password_element = new_password.nameForAutofill();
     password_form->new_password_value = new_password.value();
-    if (HasAutocompleteAttributeValue(new_password, "new-password"))
+    if (HasAutocompleteAttributeValue(new_password, kAutocompleteNewPassword))
       password_form->new_password_marked_by_site = true;
   }
 
   if (username_element.isNull()) {
     // To get a better idea on how password forms without a username field
     // look like, report the total number of text and password fields.
     UMA_HISTOGRAM_COUNTS_100(
         "PasswordManager.EmptyUsernames.TextAndPasswordFieldCount",
         layout_sequence.size());
     // For comparison, also report the number of password fields.
@@ skipping 55 matching lines @@
   WebFormElementToFormData(web_form,
                            blink::WebFormControlElement(),
                            EXTRACT_NONE,
                            &password_form->form_data,
                            NULL /* FormFieldData */);
 
   return password_form.Pass();
 }
 
 }  // namespace autofill