[Autofill] Remove longest common prefix from field names when running heuristics.

components/autofill/core/browser/form_structure.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/core/browser/form_structure.h"
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <map>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 22 matching lines @@
 const char kBillingMode[] = "billing";
 const char kShippingMode[] = "shipping";
 
 // Strip away >= 5 consecutive digits.
 const char kIgnorePatternInFieldName[] = "\\d{5,}";
 
 // A form is considered to have a high prediction mismatch rate if the number of
 // mismatches exceeds this threshold.
 const int kNumberOfMismatchesThreshold = 3;
 
+// Only removing common name prefixes if we have a minimum number of fields and
+// a minimum prefix length. These values are chosen to avoid cases such as two
+// fields with "address1" and "address2" and be effective against web frameworks
+// which prepend prefixes such as "ctl01$ctl00$MainContentRegion$" on all
+// fields.
+const int kCommonNamePrefixRemovalFieldThreshold = 3;
+const int kMinCommonNamePrefixLength = 10;
+
 // Maximum number of characters in the field label to be encoded in a proto.
 const int kMaxFieldLabelNumChars = 200;
 
 // Returns whether sending autofill field metadata to the server is enabled.
 bool IsAutofillFieldMetadataEnabled() {
   const std::string group_name =
       base::FieldTrialList::FindFullName("AutofillFieldMetadata");
   return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
 }
 
@@ skipping 251 matching lines @@
       has_password_field_ = true;
 
     // Generate a unique name for this field by appending a counter to the name.
     // Make sure to prepend the counter with a non-numeric digit so that we are
     // guaranteed to avoid collisions.
     base::string16 unique_name =
         field.name + base::ASCIIToUTF16("_") +
         base::SizeTToString16(++unique_names[field.name]);
     fields_.push_back(new AutofillField(field, unique_name));
   }
+
+  // Do further processing on the fields, as needed.
+  ProcessExtractedFields();
 }
 
 FormStructure::~FormStructure() {}
 
 void FormStructure::DetermineHeuristicTypes() {
   // First, try to detect field types based on each field's |autocomplete|
   // attribute value.  If there is at least one form field that specifies an
   // autocomplete type hint, don't try to apply other heuristics to match fields
   // in this form.
   if (!was_parsed_for_autocomplete_attributes_)
@@ skipping 902 matching lines @@
       field->set_section(field->section() + "-cc");
     else
       field->set_section(field->section() + "-default");
   }
 }
 
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
   return field.is_checkable;
 }
 
+void FormStructure::ProcessExtractedFields() {
+  // Update the field name parsed by heuristics if several criteria are met.
+  // Several fields must be present in the form.
+  if (field_count() < kCommonNamePrefixRemovalFieldThreshold)
+    return;
+
+  // Find the longest common prefix within all the field names.
+  std::vector<base::string16> names;
+  names.reserve(field_count());
+  for (const AutofillField* field : *this)
+    names.push_back(field->name);
+
+  base::StringPiece16 longest_prefix = FindLongestCommonPrefix(names);
+  if (longest_prefix.size() < kMinCommonNamePrefixLength)
+    return;
+
+  // The name without the prefix will be used for heuristics parsing.
+  for (AutofillField* field : *this) {
+    field->set_parseable_name(
+        field->name.substr(longest_prefix.size(), field->name.size()));
+  }
+}
+
+// static
+base::StringPiece16 FormStructure::FindLongestCommonPrefix(
+    const std::vector<base::string16>& strings) {
+  if (strings.empty())
+    return base::StringPiece16();
+
+  // Go through each character of the first string until there is a mismatch at
+  // the same position in any other string. Adapted from http://goo.gl/YGukMM.
+  for (size_t prefix_len = 0; prefix_len < strings[0].size(); prefix_len++) {
+    for (size_t i = 1; i < strings.size(); i++) {
+      if (prefix_len >= strings[i].size() ||
+          strings[i].at(prefix_len) != strings[0].at(prefix_len)) {
+        // Mismatch found.
+        return base::StringPiece16(strings[i].data(), prefix_len);
+      }
+    }
+  }
+  return strings[0];
+}
+
 }  // namespace autofill