[Password Generation] Sends the flag whether a field has nonempty user input

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/i18n/case_conversion.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop.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_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"
@@ skipping 304 matching lines @@
         base::StartsWith(base::i18n::ToLower(login.first),
                          current_username_lower,
                          base::CompareCase::SENSITIVE)) {
       return true;
     }
   }
 
   return false;
 }
 
+// Updates the value (i.e. the pair of elements's value |value| and field
+// properties |added_flags|) associated with the key |element| in
+// |field_value_and_properties_map|.
+// Flags in |added_flags| are added with bitwise OR operation.
+// If |value| is null, the value isn't updated.
+void UpdateFieldValueAndPropertiesMaskMap(
+    const blink::WebFormControlElement& element,
+    const base::string16* value,
+    FieldPropertiesMask added_flags,
+    FieldValueAndPropertiesMaskMap* field_value_and_properties_map) {
+  FieldValueAndPropertiesMaskMap::iterator it =
+      field_value_and_properties_map->find(element);
+  if (it != field_value_and_properties_map->end()) {
+    if (value)
+      it->second.first = *value;
+    it->second.second |= added_flags;
+  } else {
+    (*field_value_and_properties_map)[element] =
+        std::make_pair(value ? *value : base::string16(), added_flags);
+  }
+}
+
 // 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.
+// |field_value_and_properties_map| will be modified with the autofilled
+// credentials and |FieldPropertiesFlags::AUTOFILLED| flag.
 bool FillUserNameAndPassword(
     blink::WebInputElement* username_element,
     blink::WebInputElement* password_element,
     const PasswordFormFillData& fill_data,
     bool exact_username_match,
     bool set_selection,
-    std::map<const blink::WebInputElement, blink::WebString>*
-        nonscript_modified_values,
+    FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     base::Callback<void(blink::WebInputElement*)> registration_callback,
     RendererSavePasswordProgressLogger* logger) {
   if (logger)
     logger->LogMessage(Logger::STRING_FILL_USERNAME_AND_PASSWORD_METHOD);
 
   // Don't fill username if password can't be set.
   if (!IsElementAutocompletable(*password_element))
     return false;
 
   base::string16 current_username;
@@ skipping 46 matching lines @@
     return false;
 
   // TODO(tkent): Check maxlength and pattern for both username and password
   // fields.
 
   // Input matches the username, fill in required values.
   if (!username_element->isNull() &&
       IsElementAutocompletable(*username_element)) {
     // TODO(crbug.com/507714): Why not setSuggestedValue?
     username_element->setValue(username, true);
-    (*nonscript_modified_values)[*username_element] = username;
+    UpdateFieldValueAndPropertiesMaskMap(*username_element, &username,
+                                         FieldPropertiesFlags::AUTOFILLED,
+                                         field_value_and_properties_map);
     username_element->setAutofilled(true);
     if (logger)
       logger->LogElementName(Logger::STRING_USERNAME_FILLED, *username_element);
     if (set_selection) {
       form_util::PreviewSuggestion(username, current_username,
                                    username_element);
     }
   } 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);
-  (*nonscript_modified_values)[*password_element] = password;
+  UpdateFieldValueAndPropertiesMaskMap(*password_element, &password,
+                                       FieldPropertiesFlags::AUTOFILLED,
+                                       field_value_and_properties_map);
   registration_callback.Run(password_element);
 
   password_element->setAutofilled(true);
   if (logger)
     logger->LogElementName(Logger::STRING_PASSWORD_FILLED, *password_element);
   return true;
 }
 
 // Attempts to fill |username_element| and |password_element| with the
 // |fill_data|. Will use the data corresponding to the preferred username,
 // unless the |username_element| already has a value set. In that case,
 // attempts to fill the password matching the already filled username, if
 // such a password exists. The |password_element| will have the
 // |suggestedValue| set, and |suggestedValue| will be registered for copying to
 // the real value through |registration_callback|. Returns true if the password
 // is filled.
 bool FillFormOnPasswordReceived(
     const PasswordFormFillData& fill_data,
     blink::WebInputElement username_element,
     blink::WebInputElement password_element,
-    std::map<const blink::WebInputElement, blink::WebString>*
-        nonscript_modified_values,
+    FieldValueAndPropertiesMaskMap* field_value_and_properties_map,
     base::Callback<void(blink::WebInputElement*)> registration_callback,
     RendererSavePasswordProgressLogger* logger) {
   // Do not fill if the password field is in a chain of iframes not having
   // identical origin.
   blink::WebFrame* cur_frame = password_element.document().frame();
   blink::WebString bottom_frame_origin =
       cur_frame->getSecurityOrigin().toString();
 
   DCHECK(cur_frame);
 
@@ skipping 38 matching lines @@
   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 */,
-      nonscript_modified_values, registration_callback, logger);
+      field_value_and_properties_map, registration_callback, logger);
 }
 
 // Takes a |map| with pointers as keys and linked_ptr as values, and returns
 // true if |key| is not NULL and  |map| contains a non-NULL entry for |key|.
 // Makes sure not to create an entry as a side effect of using the operator [].
 template <class Key, class Value>
 bool ContainsNonNullEntryForNonNullKey(
     const std::map<Key*, linked_ptr<Value>>& map,
     Key* key) {
   if (!key)
@@ skipping 77 matching lines @@
 
   blink::WebInputElement password = password_info.password_field;
   if (!IsElementEditable(password))
     return false;
 
   blink::WebInputElement username = element;  // We need a non-const.
 
   // Do not set selection when ending an editing session, otherwise it can
   // mess with focus.
   FillUserNameAndPassword(&username, &password, fill_data, true, false,
-                          &nonscript_modified_values_,
+                          &field_value_and_properties_map_,
                           base::Bind(&PasswordValueGatekeeper::RegisterElement,
                                      base::Unretained(&gatekeeper_)),
                           nullptr);
   return true;
 }
 
 bool PasswordAutofillAgent::TextDidChangeInTextField(
     const blink::WebInputElement& element) {
   // TODO(vabr): Get a mutable argument instead. http://crbug.com/397083
   blink::WebInputElement mutable_element = element;  // We need a non-const.
@@ skipping 10 matching lines @@
 
   // Show the popup with the list of available usernames.
   return ShowSuggestions(element, false, false);
 }
 
 void PasswordAutofillAgent::UpdateStateForTextChange(
     const blink::WebInputElement& element) {
   // TODO(vabr): Get a mutable argument instead. http://crbug.com/397083
   blink::WebInputElement mutable_element = element;  // We need a non-const.
 
-  if (element.isTextField())
-    nonscript_modified_values_[element] = element.value();
+  if (element.isTextField()) {
+    const base::string16 element_value = element.value();
+    UpdateFieldValueAndPropertiesMaskMap(element, &element_value,
+                                         FieldPropertiesFlags::USER_TYPED,
+                                         &field_value_and_properties_map_);
+  }
 
   blink::WebFrame* const element_frame = element.document().frame();
   // The element's frame might have been detached in the meantime (see
   // http://crbug.com/585363, comments 5 and 6), in which case frame() will
   // return null. This was hardly caused by form submission (unless the user
   // is supernaturally quick), so it is OK to drop the ball here.
   if (!element_frame)
     return;
   DCHECK_EQ(element_frame, render_frame()->GetWebFrame());
 
   // Some login forms have event handlers that put a hash of the password into
   // a hidden field and then clear the password (http://crbug.com/28910,
   // http://crbug.com/391693). This method gets called before any of those
   // handlers run, so save away a copy of the password in case it gets lost.
   // To honor the user having explicitly cleared the password, even an empty
   // password will be saved here.
   std::unique_ptr<PasswordForm> password_form;
   if (element.form().isNull()) {
     password_form = CreatePasswordFormFromUnownedInputElements(
-        *element_frame, &nonscript_modified_values_, &form_predictions_);
+        *element_frame, &field_value_and_properties_map_, &form_predictions_);
   } else {
     password_form = CreatePasswordFormFromWebForm(
-        element.form(), &nonscript_modified_values_, &form_predictions_);
+        element.form(), &field_value_and_properties_map_, &form_predictions_);
   }
   ProvisionallySavePassword(std::move(password_form), RESTRICTION_NONE);
 
   if (element.isPasswordField()) {
     PasswordToLoginMap::iterator iter = password_to_username_.find(element);
     if (iter != password_to_username_.end()) {
       web_input_to_password_info_[iter->second].password_was_edited_last = true;
       // Note that the suggested value of |mutable_element| was reset when its
       // value changed.
       mutable_element.setAutofilled(false);
@@ skipping 22 matching lines @@
     return false;
   }
 
   password_info->password_was_edited_last = false;
   if (element->isPasswordField()) {
     password_info->password_field_suggestion_was_accepted = true;
     password_info->password_field = password_element;
   } else if (!username_element.isNull()) {
     username_element.setValue(username, true);
     username_element.setAutofilled(true);
-    nonscript_modified_values_[username_element] = username;
+    const base::string16 username_value = username;
+    UpdateFieldValueAndPropertiesMaskMap(username_element, &username_value,
+                                         FieldPropertiesFlags::AUTOFILLED,
+                                         &field_value_and_properties_map_);
   }
 
   password_element.setValue(password, true);
   password_element.setAutofilled(true);
-  nonscript_modified_values_[password_element] = password;
+  const base::string16 password_value = password;
+  UpdateFieldValueAndPropertiesMaskMap(password_element, &password_value,
+                                       FieldPropertiesFlags::AUTOFILLED,
+                                       &field_value_and_properties_map_);
 
   blink::WebInputElement mutable_filled_element = *element;
   mutable_filled_element.setSelectionRange(element->value().length(),
                                            element->value().length());
 
   return true;
 }
 
 bool PasswordAutofillAgent::PreviewSuggestion(
     const blink::WebFormControlElement& control_element,
@@ skipping 356 matching lines @@
   //
   // User-typed password will get stored to |provisionally_saved_form_| in
   // TextDidChangeInTextField. Autofilled or JavaScript-copied passwords need to
   // be saved here.
   //
   // Only non-empty passwords are saved here. Empty passwords were likely
   // cleared by some scripts (http://crbug.com/28910, http://crbug.com/391693).
   // Had the user cleared the password, |provisionally_saved_form_| would
   // already have been updated in TextDidChangeInTextField.
   std::unique_ptr<PasswordForm> password_form = CreatePasswordFormFromWebForm(
-      form, &nonscript_modified_values_, &form_predictions_);
+      form, &field_value_and_properties_map_, &form_predictions_);
   ProvisionallySavePassword(std::move(password_form),
                             RESTRICTION_NON_EMPTY_PASSWORD);
 }
 
 void PasswordAutofillAgent::WillSubmitForm(const blink::WebFormElement& form) {
   std::unique_ptr<RendererSavePasswordProgressLogger> logger;
   if (logging_state_active_) {
     logger.reset(new RendererSavePasswordProgressLogger(this, routing_id()));
     logger->LogMessage(Logger::STRING_WILL_SUBMIT_FORM_METHOD);
     LogHTMLForm(logger.get(), Logger::STRING_HTML_FORM_FOR_SUBMIT, form);
   }
 
   std::unique_ptr<PasswordForm> submitted_form = CreatePasswordFormFromWebForm(
-      form, &nonscript_modified_values_, &form_predictions_);
+      form, &field_value_and_properties_map_, &form_predictions_);
 
   // If there is a provisionally saved password, copy over the previous
   // password value so we get the user's typed password, not the value that
   // may have been transformed for submit.
   // TODO(gcasto): Do we need to have this action equality check? Is it trying
   // to prevent accidentally copying over passwords from a different form?
   if (submitted_form) {
     if (logger) {
       logger->LogPasswordForm(Logger::STRING_CREATED_PASSWORD_FORM,
                               *submitted_form);
@@ skipping 70 matching lines @@
       render_frame()->GetWebFrame()->document().forms(forms);
 
       bool password_forms_found = false;
       for (size_t i = 0; i < forms.size(); ++i) {
         blink::WebFormElement form_element = forms[i];
         if (logger) {
           LogHTMLForm(logger.get(), Logger::STRING_FORM_FOUND_ON_PAGE,
                       form_element);
         }
         possible_submitted_forms.push_back(CreatePasswordFormFromWebForm(
-            form_element, &nonscript_modified_values_, &form_predictions_));
+            form_element, &field_value_and_properties_map_,
+            &form_predictions_));
       }
 
       possible_submitted_forms.push_back(
           CreatePasswordFormFromUnownedInputElements(
-              *render_frame()->GetWebFrame(),
-              &nonscript_modified_values_,
+              *render_frame()->GetWebFrame(), &field_value_and_properties_map_,
               &form_predictions_));
 
       for (const PasswordForm* password_form : possible_submitted_forms) {
         if (password_form && !password_form->username_value.empty() &&
             FormContainsNonDefaultPasswordValue(*password_form)) {
           password_forms_found = true;
           if (logger) {
             logger->LogPasswordForm(Logger::STRING_PASSWORD_FORM_FOUND_ON_PAGE,
                                     *password_form);
           }
@@ skipping 31 matching lines @@
 
   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_,
+        &field_value_and_properties_map_,
         base::Bind(&PasswordValueGatekeeper::RegisterElement,
                    base::Unretained(&gatekeeper_)),
         logger.get());
   }
 }
 
 void PasswordAutofillAgent::GetFillableElementFromFormData(
     int key,
     const PasswordFormFillData& form_data,
     RendererSavePasswordProgressLogger* logger,
@@ skipping 67 matching lines @@
     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::FocusedNodeHasChanged(const blink::WebNode& node) {
+  if (node.isNull() || !node.isElementNode())
+    return;
+  const blink::WebElement web_element = node.toConst<blink::WebElement>();
+  if (!web_element.isFormControlElement())
+    return;
+  const blink::WebFormControlElement control_element =
+      web_element.toConst<blink::WebFormControlElement>();
+  UpdateFieldValueAndPropertiesMaskMap(control_element, nullptr,
+                                       FieldPropertiesFlags::HAD_FOCUS,
+                                       &field_value_and_properties_map_);
+}
+
 void PasswordAutofillAgent::OnSetLoggingState(bool active) {
   logging_state_active_ = active;
 }
 
 void PasswordAutofillAgent::OnAutofillUsernameAndPasswordDataReceived(
     const FormsPredictionsMap& predictions) {
   form_predictions_.insert(predictions.begin(), predictions.end());
 }
 
 void PasswordAutofillAgent::OnFindFocusedPasswordForm() {
   std::unique_ptr<PasswordForm> password_form;
 
   blink::WebElement element =
       render_frame()->GetWebFrame()->document().focusedElement();
   if (!element.isNull() && element.hasHTMLTagName("input")) {
     blink::WebInputElement input = element.to<blink::WebInputElement>();
     if (input.isPasswordField() && !input.form().isNull()) {
       if (!input.form().isNull()) {
         password_form = CreatePasswordFormFromWebForm(
-            input.form(), &nonscript_modified_values_, &form_predictions_);
+            input.form(), &field_value_and_properties_map_, &form_predictions_);
       } else {
         password_form = CreatePasswordFormFromUnownedInputElements(
-            *render_frame()->GetWebFrame(),
-            &nonscript_modified_values_, &form_predictions_);
+            *render_frame()->GetWebFrame(), &field_value_and_properties_map_,
+            &form_predictions_);
         // Only try to use this form if |input| is one of the password elements
         // for |password_form|.
         if (password_form->password_element != input.nameForAutofill() &&
             password_form->new_password_element != input.nameForAutofill())
           password_form.reset();
       }
     }
   }
 
   if (!password_form)
@@ skipping 48 matching lines @@
   username_query_prefix_ = username_string;
   return CanShowSuggestion(password_info.fill_data, username_string, show_all);
 }
 
 void PasswordAutofillAgent::FrameClosing() {
   for (auto const& iter : web_input_to_password_info_) {
     password_to_username_.erase(iter.second.password_field);
   }
   web_input_to_password_info_.clear();
   provisionally_saved_form_.reset();
-  nonscript_modified_values_.clear();
+  field_value_and_properties_map_.clear();
 }
 
 void PasswordAutofillAgent::ClearPreview(
     blink::WebInputElement* username,
     blink::WebInputElement* password) {
   if (!username->isNull() && !username->suggestedValue().isEmpty()) {
     username->setSuggestedValue(blink::WebString());
     username->setAutofilled(was_username_autofilled_);
     username->setSelectionRange(username_query_prefix_.length(),
                                 username->value().length());
@@ skipping 21 matching lines @@
          !(provisionally_saved_form_->password_value.empty() &&
          provisionally_saved_form_->new_password_value.empty());
 }
 
 const mojom::AutofillDriverPtr& PasswordAutofillAgent::GetAutofillDriver() {
   DCHECK(autofill_agent_);
   return autofill_agent_->GetAutofillDriver();
 }
 
 }  // namespace autofill