Refactoring PasswordAutofillAgent::FillUserNameAndPassword function.

components/autofill/content/renderer/password_autofill_agent.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_autofill_agent.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 174 matching lines @@
 // Returns |true| if the given element is both editable and has permission to be
 // autocompleted. The latter can be either because there is no
 // autocomplete='off' set for the element, or because the flag is set to ignore
 // autocomplete='off'. Otherwise, returns |false|.
 bool IsElementAutocompletable(const blink::WebInputElement& element) {
   return IsElementEditable(element) &&
          (ShouldIgnoreAutocompleteOffForPasswordFields() ||
           element.autoComplete());
 }
 
+// Returns |true| if element1 and element2 are IsElementAutocompletable.
+// Otherwise returns |false|.
+bool IsElementsAutocompletable(const blink::WebInputElement& element1,

[Mike West, 2014/09/18 10:25:14]

Nit: _Are_ElementsAutocompletable.

+                               const blink::WebInputElement& element2) {
+  return IsElementAutocompletable(element1) &&
+         IsElementAutocompletable(element2);
+}
+
 // Returns true if the password specified in |form| is a default value.
 bool PasswordValueIsDefault(const PasswordForm& form,
                             blink::WebFormElement form_element) {
   blink::WebVector<blink::WebNode> temp_elements;
   form_element.getNamedElements(form.password_element, temp_elements);
 
   // We are loose in our definition here and will return true if any of the
   // appropriately named elements match the element to be saved. Currently
   // we ignore filling passwords where naming is ambigious anyway.
   for (size_t i = 0; i < temp_elements.size(); ++i) {
@@ skipping 143 matching lines @@
   blink::WebInputElement password = iter->second.password_field;
   if (password.isAutofilled()) {
     password.setValue(base::string16(), true);
     password.setAutofilled(false);
   }
 
   // If wait_for_username is true we will fill when the username loses focus.
   if (iter->second.fill_data.wait_for_username)
     return false;
 
-  if (!element.isText() || !IsElementAutocompletable(element) ||
-      !IsElementAutocompletable(password)) {
+  if (!element.isText() || !IsElementsAutocompletable(element, password)) {
     return false;
   }
 
   // Don't inline autocomplete if the user is deleting, that would be confusing.
   // But refresh the popup.  Note, since this is ours, return true to signal
   // no further processing is required.
   if (iter->second.backspace_pressed_last) {
     ShowSuggestionPopup(iter->second.fill_data, element, false);
     return true;
   }
@@ skipping 29 matching lines @@
 }
 
 bool PasswordAutofillAgent::FillSuggestion(
     const blink::WebNode& node,
     const blink::WebString& username,
     const blink::WebString& password) {
   blink::WebInputElement username_element;
   PasswordInfo* password_info;
 
   if (!FindLoginInfo(node, &username_element, &password_info) ||
-      !IsElementAutocompletable(username_element) ||
-      !IsElementAutocompletable(password_info->password_field)) {
+      !IsElementsAutocompletable(username_element,
+                                 password_info->password_field)) {
     return false;
   }
 
   password_info->password_was_edited_last = false;
   username_element.setValue(username, true);
   username_element.setAutofilled(true);
   username_element.setSelectionRange(username.length(), username.length());
 
   password_info->password_field.setValue(password, true);
   password_info->password_field.setAutofilled(true);
 
   return true;
 }
 
 bool PasswordAutofillAgent::PreviewSuggestion(
     const blink::WebNode& node,
     const blink::WebString& username,
     const blink::WebString& password) {
   blink::WebInputElement username_element;
   PasswordInfo* password_info;
 
   if (!FindLoginInfo(node, &username_element, &password_info) ||
-      !IsElementAutocompletable(username_element) ||
-      !IsElementAutocompletable(password_info->password_field)) {
+      !IsElementsAutocompletable(username_element,
+                                 password_info->password_field)) {
     return false;
   }
 
   was_username_autofilled_ = username_element.isAutofilled();
   username_selection_start_ = username_element.selectionStart();
   username_element.setSuggestedValue(username);
   username_element.setAutofilled(true);
   username_element.setSelectionRange(
       username_selection_start_,
       username_element.suggestedValue().length());
@@ skipping 21 matching lines @@
     bool show_all) {
   LoginToPasswordInfoMap::const_iterator iter =
       login_to_password_info_.find(element);
   if (iter == login_to_password_info_.end())
     return false;
 
   // If autocomplete='off' is set on the form elements, no suggestion dialog
   // should be shown. However, return |true| to indicate that this is a known
   // password form and that the request to show suggestions has been handled (as
   // a no-op).
-  if (!IsElementAutocompletable(element) ||
-      !IsElementAutocompletable(iter->second.password_field))
+  if (!IsElementsAutocompletable(element, iter->second.password_field))
     return true;
 
   return ShowSuggestionPopup(iter->second.fill_data, element, show_all);
 }
 
 bool PasswordAutofillAgent::OriginCanAccessPasswordManager(
     const blink::WebSecurityOrigin& origin) {
   return origin.canAccessPasswordManager();
 }
 
@@ skipping 470 matching lines @@
     blink::WebInputElement* username_element,
     blink::WebInputElement* password_element,
     const PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection) {
   base::string16 current_username = username_element->value();
   // username and password will contain the match found if any.
   base::string16 username;
   base::string16 password;
 
+  // Don't fill username if password can't be set.
+  if (!IsElementAutocompletable(*password_element))

[vabr (Chromium), 2014/09/18 09:14:24]

Since you asked explicitly: yes, moving this check up seems OK.

[Deepak, 2014/09/18 09:35:13]

Thanks.

+    return false;
+
   // Look for any suitable matches to current field text.
   if (DoUsernamesMatch(fill_data.basic_data.fields[0].value,
                        current_username,
                        exact_username_match)) {
     username = fill_data.basic_data.fields[0].value;
     password = fill_data.basic_data.fields[1].value;
   } else {
     // Scan additional logins for a match.
-    PasswordFormFillData::LoginCollection::const_iterator iter;
-    for (iter = fill_data.additional_logins.begin();
-         iter != fill_data.additional_logins.end();
-         ++iter) {
-      if (DoUsernamesMatch(
-              iter->first, current_username, exact_username_match)) {
-        username = iter->first;
-        password = iter->second.password;
-        break;
-      }
-    }
+    CheckLoginCollectionForMatch(
+        fill_data, current_username, exact_username_match, username, password);
+    // Check possible usernames.
+    if (username.empty() && password.empty())
+      CheckUsernamesCollectionForMatch(fill_data,
+                                       current_username,
+                                       exact_username_match,
+                                       username,
+                                       password);
+  }
 
-    // Check possible usernames.
-    if (username.empty() && password.empty()) {
-      for (PasswordFormFillData::UsernamesCollection::const_iterator iter =
-               fill_data.other_possible_usernames.begin();
-           iter != fill_data.other_possible_usernames.end();
-           ++iter) {
-        for (size_t i = 0; i < iter->second.size(); ++i) {
-          if (DoUsernamesMatch(
-                  iter->second[i], current_username, exact_username_match)) {
-            usernames_usage_ = OTHER_POSSIBLE_USERNAME_SELECTED;
-            username = iter->second[i];
-            password = iter->first.password;
-            break;
-          }
-        }
-        if (!username.empty() && !password.empty())
-          break;
-      }
-    }
-  }
   if (password.empty())
     return false;  // No match was found.
 
   // TODO(tkent): Check maxlength and pattern for both username and password
   // fields.
 
-  // Don't fill username if password can't be set.
-  if (!IsElementAutocompletable(*password_element)) {
-    return false;
-  }
-
   // Input matches the username, fill in required values.
   if (IsElementAutocompletable(*username_element)) {
     username_element->setValue(username, true);
     username_element->setAutofilled(true);
 
     if (set_selection) {
       username_element->setSelectionRange(current_username.length(),
                                           username.length());
     }
   } else if (current_username != username) {
     // If the username can't be filled and it doesn't match a saved password
     // as is, don't autofill a password.
     return false;
   }
-
   // Wait to fill in the password until a user gesture occurs. This is to make
   // sure that we do not fill in the DOM with a password until we believe the
   // user is intentionally interacting with the page.
   password_element->setSuggestedValue(password);
   gatekeeper_.RegisterElement(password_element);
 
   password_element->setAutofilled(true);
   return true;
 }
 
+// Check additional names for match.
+void PasswordAutofillAgent::CheckLoginCollectionForMatch(

[vabr (Chromium), 2014/09/18 09:14:24]

Why separating the code into the two functions here, when it is only called at
one place? I suggest reverting back to inlining in this case.

[Deepak, 2014/09/18 09:35:13]

ok, I will make this again inline as earlier.

+    const PasswordFormFillData& fill_data,
+    const base::string16 current_username,
+    const bool exact_username_match,
+    base::string16& username,
+    base::string16& password) {
+  for (PasswordFormFillData::LoginCollection::const_iterator iter =
+           fill_data.additional_logins.begin();
+       iter != fill_data.additional_logins.end();
+       ++iter) {
+    if (DoUsernamesMatch(iter->first, current_username, exact_username_match)) {
+      username = iter->first;
+      password = iter->second.password;
+      break;
+    }
+  }
+}
+
+// Check possible usernames.
+void PasswordAutofillAgent::CheckUsernamesCollectionForMatch(
+    const PasswordFormFillData& fill_data,
+    const base::string16 current_username,
+    const bool exact_username_match,
+    base::string16& username,
+    base::string16& password) {
+  for (PasswordFormFillData::UsernamesCollection::const_iterator iter =
+           fill_data.other_possible_usernames.begin();
+       iter != fill_data.other_possible_usernames.end();
+       ++iter) {
+    for (size_t i = 0; i < iter->second.size(); ++i) {
+      if (DoUsernamesMatch(
+              iter->second[i], current_username, exact_username_match)) {
+        usernames_usage_ = OTHER_POSSIBLE_USERNAME_SELECTED;
+        username = iter->second[i];
+        password = iter->first.password;
+        break;
+      }
+    }
+    if (!username.empty() && !password.empty())
+      break;
+  }
+}
+
 void PasswordAutofillAgent::PerformInlineAutocomplete(
     const blink::WebInputElement& username_input,
     const blink::WebInputElement& password_input,
     const PasswordFormFillData& fill_data) {
   DCHECK(!fill_data.wait_for_username);
 
   // We need non-const versions of the username and password inputs.
   blink::WebInputElement username = username_input;
   blink::WebInputElement password = password_input;
 
@@ skipping 81 matching lines @@
   scoped_ptr<PasswordForm> password_form(CreatePasswordForm(form));
   if (!password_form || (restriction == RESTRICTION_NON_EMPTY_PASSWORD &&
                          password_form->password_value.empty() &&
                          password_form->new_password_value.empty())) {
     return;
   }
   provisionally_saved_forms_[frame].reset(password_form.release());
 }
 
 }  // namespace autofill