Password Manager: collect data about autofilled values on iOS.

One of the obstacles for recording the FillingAssistance metric on iOS
is that it's not always possible to recoved autofilled values.
Now they are stored in FieldDataManager as well.

Bug: 918846
Change-Id: Ic2bbbd5b5bc5ea61230ab8844a2278d8adc64168
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2302112
Commit-Queue: Maria Kazinova <kazinova@google.com>
Reviewed-by: Vadym Doroshenko  <dvadym@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789452}

components/autofill/core/common/field_data_manager.cc

@@ -85,6 +85,27 @@ bool FieldDataManager::WasAutofilledOnUserTrigger(FieldRendererId id) const {
                               FieldPropertiesFlags::kAutofilledOnUserTrigger);
 }
 
+bool FieldDataManager::WasAutofilledOnPageLoad(FieldRendererId id) const {
+  return HasFieldData(id) && (GetFieldPropertiesMask(id) &
+                              FieldPropertiesFlags::kAutofilledOnPageLoad);
+}
+
+void FieldDataManager::UpdateFieldDataWithAutofilledValue(
+    FieldRendererId id,
+    const base::string16& value,
+    FieldPropertiesMask mask) {
+  UpdateFieldDataMapWithNullValue(id, mask);
+  autofilled_values_map_[id] = value;
+}
+
+base::Optional<base::string16> FieldDataManager::GetAutofilledValue(
+    FieldRendererId id) const {
+  if (autofilled_values_map_.count(id))
+    return base::Optional<base::string16>(autofilled_values_map_.at(id));
+  else
+    return base::nullopt;
+}
+
 FieldDataManager::~FieldDataManager() = default;
 
 }  // namespace autofill

components/autofill/core/common/field_data_manager.h

@@ -52,12 +52,24 @@ class FieldDataManager : public base::RefCounted<FieldDataManager> {
     return field_value_and_properties_map_;
   }
 
+  bool WasAutofilledOnPageLoad(FieldRendererId id) const;
+
+  // Update data with autofilled value.
+  void UpdateFieldDataWithAutofilledValue(FieldRendererId id,
+                                          const base::string16& value,
+                                          FieldPropertiesMask mask);
+
+  base::Optional<base::string16> GetAutofilledValue(FieldRendererId id) const;
+
  private:
   friend class base::RefCounted<FieldDataManager>;
 
   ~FieldDataManager();
 
   FieldDataMap field_value_and_properties_map_;
+
+  // Stores values autofilled either on page load or on user trigger.
+  std::map<FieldRendererId, base::string16> autofilled_values_map_;
 };
 
 }  // namespace autofill

components/autofill/core/common/field_data_manager_unittest.cc

@@ -105,4 +105,20 @@ TEST_F(FieldDataManagerTest, FindMachedValue) {
       field_data_manager->FindMachedValue(UTF8ToUTF16("second_element")));
 }
 
+TEST_F(FieldDataManagerTest, UpdateFieldDataMapWithAutofilledValue) {
+  const scoped_refptr<FieldDataManager> field_data_manager =
+      base::MakeRefCounted<FieldDataManager>();
+  const FieldRendererId id(control_elements_[0].unique_renderer_id);
+  field_data_manager->UpdateFieldDataWithAutofilledValue(
+      id, ASCIIToUTF16("autofilled"),
+      FieldPropertiesFlags::kAutofilledOnPageLoad);
+
+  EXPECT_TRUE(field_data_manager->HasFieldData(id));
+  EXPECT_EQ(base::string16(), field_data_manager->GetUserTypedValue(id));
+  EXPECT_EQ(UTF8ToUTF16("autofilled"),
+            field_data_manager->GetAutofilledValue(id));
+  EXPECT_EQ(FieldPropertiesFlags::kAutofilledOnPageLoad,
+            field_data_manager->GetFieldPropertiesMask(id));
+}
+
 }  // namespace autofill

components/password_manager/core/browser/password_form_manager.cc

@@ -35,6 +35,7 @@
 #include "components/signin/public/identity_manager/identity_manager.h"
 #include "google_apis/gaia/core_account_id.h"
 
+using autofill::FieldDataManager;
 using autofill::FieldRendererId;
 using autofill::FormData;
 using autofill::FormFieldData;
@@ -566,6 +567,20 @@ void PasswordFormManager::SetDriver(
     const base::WeakPtr<PasswordManagerDriver>& driver) {
   driver_ = driver;
 }
+
+void PasswordFormManager::UpdateObservedFormDataWithFieldDataManagerInfo(
+    const FieldDataManager* field_data_manager) {
+  for (FormFieldData& field : observed_form_.fields) {
+    FieldRendererId field_id = field.unique_renderer_id;
+    if (!field_data_manager->HasFieldData(field_id))
+      continue;
+    field.typed_value = field_data_manager->GetUserTypedValue(field_id);
+    field.properties_mask =
+        field_data_manager->GetFieldPropertiesMask(field_id);
+    field.value =
+        field_data_manager->GetAutofilledValue(field_id).value_or(field.value);
+  }
+}
 #endif  // defined(OS_IOS)
 
 std::unique_ptr<PasswordFormManager> PasswordFormManager::Clone() {

components/password_manager/core/browser/password_form_manager.h

@@ -15,6 +15,7 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "components/autofill/core/common/field_data_manager.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/renderer_id.h"
 #include "components/autofill/core/common/signatures.h"
@@ -205,6 +206,10 @@ class PasswordFormManager : public PasswordFormManagerForUI,
                               const base::string16& field_value);
 
   void SetDriver(const base::WeakPtr<PasswordManagerDriver>& driver);
+
+  // Copies all known field data from FieldDataManager to |observed_form_|.
+  void UpdateObservedFormDataWithFieldDataManagerInfo(
+      const autofill::FieldDataManager* field_data_manager);
 #endif  // defined(OS_IOS)
 
   // Create a copy of |*this| which can be passed to the code handling

components/password_manager/core/browser/password_form_manager_unittest.cc

@@ -2070,6 +2070,32 @@ TEST_P(PasswordFormManagerTest, iOSUpdateStateWithoutPresaving) {
             form_manager_->observed_form().fields[kPasswordFieldIndex].value);
 }
 
+TEST_P(PasswordFormManagerTest, iOSUsingFieldDataManagerData) {
+  CreateFormManager(observed_form_);
+
+  auto field_data_manager = base::MakeRefCounted<autofill::FieldDataManager>();
+  field_data_manager->UpdateFieldDataMap(
+      observed_form_.fields[1].unique_renderer_id,
+      base::UTF8ToUTF16("typed_username"), FieldPropertiesFlags::kUserTyped);
+  field_data_manager->UpdateFieldDataWithAutofilledValue(
+      observed_form_.fields[2].unique_renderer_id,
+      base::UTF8ToUTF16("autofilled_pw"),
+      FieldPropertiesFlags::kAutofilledOnPageLoad);
+
+  form_manager_->UpdateObservedFormDataWithFieldDataManagerInfo(
+      field_data_manager.get());
+
+  EXPECT_EQ(form_manager_->observed_form().fields[1].typed_value,
+            base::UTF8ToUTF16("typed_username"));
+  EXPECT_EQ(form_manager_->observed_form().fields[1].properties_mask,
+            FieldPropertiesFlags::kUserTyped);
+
+  EXPECT_EQ(form_manager_->observed_form().fields[2].value,
+            base::UTF8ToUTF16("autofilled_pw"));
+  EXPECT_EQ(form_manager_->observed_form().fields[2].properties_mask,
+            FieldPropertiesFlags::kAutofilledOnPageLoad);
+}
+
 #endif  // defined(OS_IOS)
 
 // Tests that username is taken during username first flow.

components/password_manager/core/browser/password_manager.cc

@@ -51,6 +51,7 @@
 #endif
 
 using autofill::ACCOUNT_CREATION_PASSWORD;
+using autofill::FieldDataManager;
 using autofill::FieldRendererId;
 using autofill::FormData;
 using autofill::FormRendererId;
@@ -740,25 +741,30 @@ void PasswordManager::OnPasswordNoLongerGenerated(
     manager->PasswordNoLongerGenerated();
 }
 
-void PasswordManager::OnPasswordFormRemoved(PasswordManagerDriver* driver,
-                                            FormRendererId form_id) {
+void PasswordManager::OnPasswordFormRemoved(
+    PasswordManagerDriver* driver,
+    const FieldDataManager* field_data_manager,
+    FormRendererId form_id) {
   for (auto& manager : form_managers_) {
     if (driver && !manager->GetDriver())
       manager->SetDriver(driver->AsWeakPtr());
+    // Find a form with corresponding renderer id.
     if (manager->DoesManageAccordingToRendererId(form_id, driver)) {
-      if (manager->is_submitted())
-        OnLoginSuccessful();
-      else
-        return;
+      CheckForPotentialSubmission(manager.get(), field_data_manager, driver);
+      return;
     }
   }
 }
 
-void PasswordManager::OnIframeDetach(const std::string& frame_id) {
-  PasswordFormManager* submitted_manager = GetSubmittedManager();
-  if (submitted_manager &&
-      submitted_manager->observed_form().frame_id == frame_id) {
-    OnLoginSuccessful();
+void PasswordManager::OnIframeDetach(
+    const std::string& frame_id,
+    PasswordManagerDriver* driver,
+    const FieldDataManager* field_data_manager) {
+  for (auto& manager : form_managers_) {
+    // Find a form with corresponding frame id.
+    if (manager->observed_form().frame_id == frame_id) {
+      CheckForPotentialSubmission(manager.get(), field_data_manager, driver);
+    }
   }
 }
 #endif
@@ -1253,6 +1259,25 @@ void PasswordManager::ResetAutofillAssistantMode() {
   autofill_assistant_mode_ = AutofillAssistantMode::kNotRunning;
 }
 
+#if defined(OS_IOS)
+void PasswordManager::CheckForPotentialSubmission(
+    PasswordFormManager* form_manager,
+    const FieldDataManager* field_data_manager,
+    PasswordManagerDriver* driver) {
+  // If the manager is not submitted, it still can have autofilled data.
+  if (!form_manager->is_submitted()) {
+    form_manager->UpdateObservedFormDataWithFieldDataManagerInfo(
+        field_data_manager);
+    // Provisionally save form and set the manager to be submitted if valid
+    // data was recovered.
+    form_manager->ProvisionallySave(form_manager->observed_form(), driver,
+                                    nullptr);
+  }
+  if (form_manager->is_submitted())
+    OnLoginSuccessful();
+}
+#endif
+
 base::TimeDelta PasswordManager::GetTimeoutForDisablingPrompts() {
   return base::TimeDelta::FromSeconds(disable_prompts_timeout_in_seconds_);
 }

components/password_manager/core/browser/password_manager.h

@@ -110,9 +110,14 @@ class PasswordManager : public PasswordManagerInterface {
                               autofill::FieldRendererId field_id,
                               const base::string16& field_value) override;
   void OnPasswordNoLongerGenerated(PasswordManagerDriver* driver) override;
-  void OnPasswordFormRemoved(PasswordManagerDriver* driver,
-                             autofill::FormRendererId form_id) override;
-  void OnIframeDetach(const std::string& frame_id) override;
+  void OnPasswordFormRemoved(
+      PasswordManagerDriver* driver,
+      const autofill::FieldDataManager* field_data_manager,
+      autofill::FormRendererId form_id) override;
+  void OnIframeDetach(
+      const std::string& frame_id,
+      PasswordManagerDriver* driver,
+      const autofill::FieldDataManager* field_data_manager) override;
 #endif
 
   // Notifies the renderer to start the generation flow or pops up additional UI
@@ -335,6 +340,17 @@ class PasswordManager : public PasswordManagerInterface {
   // Resets |autofill_assistant_mode_| to the default.
   void ResetAutofillAssistantMode();
 
+#if defined(OS_IOS)
+  // Even though the formal submission might not happen, the manager
+  // could still be provisionally saved on user input or have autofilled data,
+  // in this case submission might be considered successful and a save prompt
+  // might be shown.
+  void CheckForPotentialSubmission(
+      PasswordFormManager* form_manager,
+      const autofill::FieldDataManager* field_data_manager,
+      PasswordManagerDriver* driver);
+#endif
+
   // PasswordFormManager transition schemes:
   // 1. HTML submission with navigation afterwads.
   // form "seen"

components/password_manager/core/browser/password_manager_interface.h

@@ -11,6 +11,7 @@
 
 #include "base/strings/string16.h"
 #include "build/build_config.h"
+#include "components/autofill/core/common/field_data_manager.h"
 #include "components/autofill/core/common/form_data.h"
 #include "components/autofill/core/common/renderer_id.h"
 #include "components/password_manager/core/browser/form_submission_observer.h"
@@ -76,12 +77,17 @@ class PasswordManagerInterface : public FormSubmissionObserver {
 
   // Call when a form is removed so that this class can decide if whether or not
   // the form was submitted.
-  virtual void OnPasswordFormRemoved(PasswordManagerDriver* driver,
-                                     autofill::FormRendererId form_id) = 0;
+  virtual void OnPasswordFormRemoved(
+      PasswordManagerDriver* driver,
+      const autofill::FieldDataManager* field_data_manager,
+      autofill::FormRendererId form_id) = 0;
 
   // Checks if there is a submitted PasswordFormManager for a form from the
   // detached frame.
-  virtual void OnIframeDetach(const std::string& frame_id) = 0;
+  virtual void OnIframeDetach(
+      const std::string& frame_id,
+      PasswordManagerDriver* driver,
+      const autofill::FieldDataManager* field_data_manager) = 0;
 #endif
 };
 

components/password_manager/ios/password_form_helper.mm

@@ -31,6 +31,7 @@ using autofill::FormData;
 using autofill::FormRendererId;
 using autofill::FieldRendererId;
 using autofill::PasswordFormFillData;
+using base::SysNSStringToUTF16;
 using password_manager::FillData;
 using password_manager::GetPageURLAndCheckTrustLevel;
 using password_manager::SerializePasswordFormFillData;
@@ -189,6 +190,10 @@ constexpr char kCommandPrefix[] = "passwordForm";
                              forms.size(), 50);
   if (forms.size() != 1)
     return;
+
+  // Extract FieldDataManager data for observed fields.
+  [self extractKnownFieldData:forms[0]];
+
   [self.delegate formHelper:self
               didSubmitForm:forms[0]
                 inMainFrame:formInMainFrame];
@@ -254,15 +259,31 @@ constexpr char kCommandPrefix[] = "passwordForm";
     return;
   }
 
+  // Necessary copy so the values can be used inside a block.
+  FieldRendererId usernameID = formData.username_field.unique_renderer_id;
+  FieldRendererId passwordID = formData.password_field.unique_renderer_id;
+  base::string16 usernameValue = username;
+  base::string16 passwordValue = password;
+
   // Send JSON over to the web view.
+  __weak PasswordFormHelper* weakSelf = self;
   [self.jsPasswordManager
        fillPasswordForm:SerializePasswordFormFillData(formData)
                 inFrame:GetMainFrame(_webState)
            withUsername:base::SysUTF16ToNSString(username)
                password:base::SysUTF16ToNSString(password)
       completionHandler:^(NSString* result) {
+        BOOL success = [result isEqual:@"true"];
+        if (success) {
+          weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+              usernameID, usernameValue,
+              FieldPropertiesFlags::kAutofilledOnPageLoad);
+          weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+              passwordID, passwordValue,
+              FieldPropertiesFlags::kAutofilledOnPageLoad);
+        }
         if (completionHandler) {
-          completionHandler([result isEqual:@"true"]);
+          completionHandler(success);
         }
       }];
 }
@@ -341,12 +362,6 @@ constexpr char kCommandPrefix[] = "passwordForm";
     return;
   }
 
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      formData.username_field.unique_renderer_id,
-      FieldPropertiesFlags::kAutofilledOnPageLoad);
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      formData.password_field.unique_renderer_id,
-      FieldPropertiesFlags::kAutofilledOnPageLoad);
   [self fillPasswordForm:formData
             withUsername:formData.username_field.value
                 password:formData.password_field.value
@@ -358,43 +373,59 @@ constexpr char kCommandPrefix[] = "passwordForm";
     confirmPasswordIdentifier:(FieldRendererId)confirmPasswordIdentifier
             generatedPassword:(NSString*)generatedPassword
             completionHandler:(nullable void (^)(BOOL))completionHandler {
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      newPasswordIdentifier, FieldPropertiesFlags::kAutofilledOnUserTrigger);
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      confirmPasswordIdentifier,
-      FieldPropertiesFlags::kAutofilledOnUserTrigger);
-
   // Send JSON over to the web view.
-  [self.jsPasswordManager fillPasswordForm:formIdentifier
-                                   inFrame:GetMainFrame(_webState)
-                     newPasswordIdentifier:newPasswordIdentifier
-                 confirmPasswordIdentifier:confirmPasswordIdentifier
-                         generatedPassword:generatedPassword
-                         completionHandler:^(NSString* result) {
-                           if (completionHandler) {
-                             completionHandler([result isEqual:@"true"]);
-                           }
-                         }];
+  __weak PasswordFormHelper* weakSelf = self;
+  [self.jsPasswordManager
+               fillPasswordForm:formIdentifier
+                        inFrame:GetMainFrame(_webState)
+          newPasswordIdentifier:newPasswordIdentifier
+      confirmPasswordIdentifier:confirmPasswordIdentifier
+              generatedPassword:generatedPassword
+              completionHandler:^(NSString* result) {
+                BOOL success = [result isEqual:@"true"];
+                if (success) {
+                  weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+                      newPasswordIdentifier,
+                      SysNSStringToUTF16(generatedPassword),
+                      FieldPropertiesFlags::kAutofilledOnUserTrigger);
+                  weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+                      confirmPasswordIdentifier,
+                      SysNSStringToUTF16(generatedPassword),
+                      FieldPropertiesFlags::kAutofilledOnUserTrigger);
+                }
+                if (completionHandler) {
+                  completionHandler(success);
+                }
+              }];
 }
 
 - (void)fillPasswordFormWithFillData:(const password_manager::FillData&)fillData
                    completionHandler:
                        (nullable void (^)(BOOL))completionHandler {
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      fillData.username_element_id,
-      FieldPropertiesFlags::kAutofilledOnUserTrigger);
-  self.fieldDataManager->UpdateFieldDataMapWithNullValue(
-      fillData.password_element_id,
-      FieldPropertiesFlags::kAutofilledOnUserTrigger);
+  // Necessary copy so the values can be used inside a block.
+  FieldRendererId usernameID = fillData.username_element_id;
+  FieldRendererId passwordID = fillData.password_element_id;
+  base::string16 usernameValue = fillData.username_value;
+  base::string16 passwordValue = fillData.password_value;
 
+  __weak PasswordFormHelper* weakSelf = self;
   [self.jsPasswordManager
        fillPasswordForm:SerializeFillData(fillData)
                 inFrame:GetMainFrame(_webState)
-           withUsername:base::SysUTF16ToNSString(fillData.username_value)
-               password:base::SysUTF16ToNSString(fillData.password_value)
+           withUsername:base::SysUTF16ToNSString(usernameValue)
+               password:base::SysUTF16ToNSString(passwordValue)
       completionHandler:^(NSString* result) {
+        BOOL success = [result isEqual:@"true"];
+        if (success) {
+          weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+              usernameID, usernameValue,
+              FieldPropertiesFlags::kAutofilledOnUserTrigger);
+          weakSelf.fieldDataManager->UpdateFieldDataWithAutofilledValue(
+              passwordID, passwordValue,
+              FieldPropertiesFlags::kAutofilledOnUserTrigger);
+        }
         if (completionHandler) {
-          completionHandler([result isEqual:@"true"]);
+          completionHandler(success);
         }
       }];
 }

ios/chrome/browser/passwords/password_controller.mm

@@ -366,9 +366,14 @@ NSString* const kSuggestionSuffix = @" ••••••••";
 // Track detaching iframes.
 - (void)webState:(WebState*)webState
     frameWillBecomeUnavailable:(WebFrame*)web_frame {
+  // No need to try to detect submissions when the webState is being destroyed.
+  if (webState->IsBeingDestroyed())
+    return;
   if (web_frame->IsMainFrame() || !web_frame->CanCallJavaScriptFunction())
     return;
-  _passwordManager->OnIframeDetach(web_frame->GetFrameId());
+  _passwordManager->OnIframeDetach(web_frame->GetFrameId(),
+                                   self.passwordManagerDriver,
+                                   self.formHelper.fieldDataManager.get());
 }
 
 #pragma mark - FormSuggestionProvider
@@ -1064,7 +1069,8 @@ NSString* const kSuggestionSuffix = @" ••••••••";
   // whether the form was submitted.
   if (params.type == "password_form_removed") {
     self.passwordManager->OnPasswordFormRemoved(
-        self.passwordManagerDriver, FormRendererId(params.unique_form_id));
+        self.passwordManagerDriver, self.formHelper.fieldDataManager.get(),
+        FormRendererId(params.unique_form_id));
   }
 }