Basic implementation of showing password fill dialog on page load

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 <stddef.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "components/autofill/content/common/autofill_messages.h"
 #include "components/autofill/content/renderer/form_autofill_util.h"
 #include "components/autofill/content/renderer/password_form_conversion_utils.h"
 #include "components/autofill/content/renderer/renderer_save_password_progress_logger.h"
 #include "components/autofill/core/common/autofill_constants.h"
-#include "components/autofill/core/common/autofill_switches.h"
 #include "components/autofill/core/common/autofill_util.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/autofill/core/common/password_form_fill_data.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebAutofillClient.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebFormElement.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "url/gurl.h"
 
 namespace autofill {
 namespace {
 
 // The size above which we stop triggering autocomplete.
 static const size_t kMaximumTextSizeForAutocomplete = 1000;
 
-// Experiment information
-const char kFillOnAccountSelectFieldTrialName[] = "FillOnAccountSelect";
-const char kFillOnAccountSelectFieldTrialEnabledWithHighlightGroup[] =
-    "EnableWithHighlight";
-const char kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup[] =
-    "EnableWithNoHighlight";
 const char kDummyUsernameField[] = "anonymous_username";
 const char kDummyPasswordField[] = "anonymous_password";
 
 // Maps element names to the actual elements to simplify form filling.
 typedef std::map<base::string16, blink::WebInputElement> FormInputElementMap;
 
 // Use the shorter name when referencing SavePasswordProgressLogger::StringID
 // values to spare line breaks. The code provides enough context for that
 // already.
 typedef SavePasswordProgressLogger Logger;
@@ skipping 147 matching lines @@
   // iteration remain in the result set.
   // Note: clear will remove a reference from each InputElement.
   if (!found_input) {
     result->clear();
     return false;
   }
 
   return true;
 }
 
-bool ShouldFillOnAccountSelect() {
-  std::string group_name =
-      base::FieldTrialList::FindFullName(kFillOnAccountSelectFieldTrialName);
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableFillOnAccountSelect)) {
-    return false;
-  }
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableFillOnAccountSelect) ||
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableFillOnAccountSelectNoHighlighting)) {
-    return true;
-  }
-
-  return group_name ==
-             kFillOnAccountSelectFieldTrialEnabledWithHighlightGroup ||
-         group_name ==
-             kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup;
-}
-
-bool ShouldHighlightFields() {
-  std::string group_name =
-      base::FieldTrialList::FindFullName(kFillOnAccountSelectFieldTrialName);
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableFillOnAccountSelect) ||
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableFillOnAccountSelect)) {
-    return true;
-  }
-
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableFillOnAccountSelectNoHighlighting)) {
-    return false;
-  }
-
-  return group_name !=
-         kFillOnAccountSelectFieldTrialEnabledWithNoHighlightGroup;
-}
-
 // Helper to search through |control_elements| for the specified input elements
 // in |data|, and add results to |result|.
 bool FindFormInputElements(
     const std::vector<blink::WebFormControlElement>& control_elements,
     const PasswordFormFillData& data,
     bool ambiguous_or_empty_names,
     FormInputElementMap* result) {
   return FindFormInputElement(control_elements, data.password_field,
                               ambiguous_or_empty_names, result) &&
          (!FillDataContainsFillableUsername(data) ||
@@ skipping 111 matching lines @@
         base::StartsWith(base::i18n::ToLower(login.first),
                          current_username_lower,
                          base::CompareCase::SENSITIVE)) {
       return true;
     }
   }
 
   return false;
 }
 
-// Returns true if there exists a credential suggestion whose username field is
-// an exact match to the current username (not just a prefix).
-bool HasExactMatchSuggestion(const PasswordFormFillData& fill_data,
-                             const base::string16& current_username) {
-  if (fill_data.username_field.value == current_username)
-    return true;
-
-  for (const auto& usernames : fill_data.other_possible_usernames) {
-    for (const auto& username_string : usernames.second) {
-      if (username_string == current_username)
-        return true;
-    }
-  }
-
-  for (const auto& login : fill_data.additional_logins) {
-    if (login.first == current_username)
-      return true;
-  }
-
-  return false;
-}
-
 // This function attempts to fill |username_element| and |password_element|
 // with values from |fill_data|. The |password_element| will only have the
 // suggestedValue set, and will be registered for copying that to the real
 // value through |registration_callback|. If a match is found, return true and
 // |nonscript_modified_values| will be modified with the autofilled credentials.
 bool FillUserNameAndPassword(
     blink::WebInputElement* username_element,
     blink::WebInputElement* password_element,
     const PasswordFormFillData& fill_data,
     bool exact_username_match,
@@ skipping 148 matching lines @@
   // If there is no autocompletable username field, and (a) is false, then the
   // username element cannot be autofilled, but the user should still be able to
   // select to fill the password element, so the password element must be marked
   // as autofilled and the fill step should also be skipped if the user is not
   // in the "no highlighting" group.
   //
   // In all other cases, do nothing.
   bool form_has_fillable_username = !username_field_name.empty() &&
                                     IsElementAutocompletable(username_element);
 
-  if (ShouldFillOnAccountSelect()) {
-    if (!ShouldHighlightFields()) {
-      return false;
-    }
-
-    if (form_has_fillable_username) {
-      username_element.setAutofilled(true);
-    } else if (username_element.isNull() ||
-               HasExactMatchSuggestion(fill_data, username_element.value())) {
-      password_element.setAutofilled(true);
-    }
-    return false;
-  }
-
   if (form_has_fillable_username && username_element.value().isEmpty()) {
     // TODO(tkent): Check maxlength and pattern.
     username_element.setValue(fill_data.username_field.value, true);
   }
 
   // Fill if we have an exact match for the username. Note that this sets
   // username to autofilled.
   return FillUserNameAndPassword(
       &username_element, &password_element, fill_data,
       true /* exact_username_match */, false /* set_selection */,
@@ skipping 705 matching lines @@
   }
 
   // This is a new navigation, so require a new user gesture before filling in
   // passwords.
   gatekeeper_.Reset();
 }
 
 void PasswordAutofillAgent::OnFillPasswordForm(
     int key,
     const PasswordFormFillData& form_data) {
+  std::vector<blink::WebInputElement> elements;
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_ON_FILL_PASSWORD_FORM_METHOD);
   }
+  GetFillableElementFromFormData(key, form_data, logger.get(), &elements);
 
+  // If wait_for_username is true, we don't want to initially fill the form
+  // until the user types in a valid username.
+  if (form_data.wait_for_username)
+    return;
+
+  for (auto element : elements) {
+    blink::WebInputElement username_element =
+        !element.isPasswordField() ? element : password_to_username_[element];
+    blink::WebInputElement password_element =
+        element.isPasswordField()
+            ? element
+            : web_input_to_password_info_[element].password_field;
+    FillFormOnPasswordReceived(
+        form_data, username_element, password_element,
+        &nonscript_modified_values_,
+        base::Bind(&PasswordValueGatekeeper::RegisterElement,
+                   base::Unretained(&gatekeeper_)),
+        logger.get());
+  }
+}
+
+void PasswordAutofillAgent::GetFillableElementFromFormData(
+    int key,
+    const PasswordFormFillData& form_data,
+    RendererSavePasswordProgressLogger* logger,
+    std::vector<blink::WebInputElement>* elements) {
+  DCHECK(elements);
   bool ambiguous_or_empty_names =
       DoesFormContainAmbiguousOrEmptyNames(form_data);
   FormElementsList forms;
   FindFormElements(render_frame(), form_data, ambiguous_or_empty_names, &forms);
   if (logger) {
     logger->LogBoolean(Logger::STRING_AMBIGUOUS_OR_EMPTY_NAMES,
                        ambiguous_or_empty_names);
     logger->LogNumber(Logger::STRING_NUMBER_OF_POTENTIAL_FORMS_TO_FILL,
                       forms.size());
     logger->LogBoolean(Logger::STRING_FORM_DATA_WAIT,
@@ skipping 43 matching lines @@
 
     blink::WebInputElement main_element =
         username_element.isNull() ? password_element : username_element;
 
     // We might have already filled this form if there are two <form> elements
     // with identical markup.
     if (web_input_to_password_info_.find(main_element) !=
         web_input_to_password_info_.end())
       continue;
 
-    // If wait_for_username is true, we don't want to initially fill the form
-    // until the user types in a valid username.
-    if (!form_data.wait_for_username) {
-      FillFormOnPasswordReceived(
-          form_data, username_element, password_element,
-          &nonscript_modified_values_,
-          base::Bind(&PasswordValueGatekeeper::RegisterElement,
-                     base::Unretained(&gatekeeper_)),
-          logger.get());
-    }
-
     PasswordInfo password_info;
     password_info.fill_data = form_data;
     password_info.key = key;
     password_info.password_field = password_element;
     web_input_to_password_info_[main_element] = password_info;
     if (!main_element.isPasswordField())
       password_to_username_[password_element] = username_element;
+    if (elements)
+      elements->push_back(main_element);
   }
 }
 
 void PasswordAutofillAgent::OnSetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
 void PasswordAutofillAgent::OnAutofillUsernameAndPasswordDataReceived(
     const FormsPredictionsMap& predictions) {
   form_predictions_.insert(predictions.begin(), predictions.end());
@@ skipping 112 matching lines @@
 }
 
 bool PasswordAutofillAgent::ProvisionallySavedPasswordIsValid() {
   return provisionally_saved_form_ &&
          !provisionally_saved_form_->username_value.empty() &&
          !(provisionally_saved_form_->password_value.empty() &&
          provisionally_saved_form_->new_password_value.empty());
 }
 
 }  // namespace autofill