Autofill server-side heuristics for 2 fields password form

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>
@@ skipping 287 matching lines @@
       source_url_(form.origin),
       target_url_(form.action),
       autofill_count_(0),
       active_field_count_(0),
       upload_required_(USE_UPLOAD_RATES),
       has_author_specified_types_(false),
       has_author_specified_sections_(false),
       was_parsed_for_autocomplete_attributes_(false),
       has_password_field_(false),
       is_form_tag_(form.is_form_tag),
-      is_formless_checkout_(form.is_formless_checkout) {
+      is_formless_checkout_(form.is_formless_checkout),
+      all_fields_are_passwords_(true) {
   // Copy the form fields.
   std::map<base::string16, size_t> unique_names;
   for (const FormFieldData& field : form.fields) {
     if (!ShouldSkipField(field)) {
       // Add all supported form fields (including with empty names) to the
       // signature.  This is a requirement for Autofill servers.
       form_signature_field_names_.append("&");
       form_signature_field_names_.append(StripDigitsIfRequired(field.name));
 
       ++active_field_count_;
     }
 
     if (field.form_control_type == "password")
       has_password_field_ = true;
+    else
+      all_fields_are_passwords_ = false;
 
     // 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));
   }
 
@@ skipping 240 matching lines @@
 
 void FormStructure::UpdateAutofillCount() {
   autofill_count_ = 0;
   for (const AutofillField* field : *this) {
     if (field && field->IsFieldFillable())
       ++autofill_count_;
   }
 }
 
 bool FormStructure::ShouldBeParsed() const {
-  if (active_field_count() < kRequiredFieldsForPredictionRoutines &&
+  if ((active_field_count() <
+           kRequiredFieldsAllPasswordsForUploadAndPrediction ||

[Ilya Sherman, 2016/02/09 22:33:39]

This logic is implicitly assuming that
kRequiredFieldsAllPasswordsForUploadAndPrediction is less than
kRequiredFieldsForPredictionRoutines.  I think it would be slightly better to
write it the other way, to match how you wrote the logic elsewhere.

[dvadym, 2016/02/10 11:58:28]

Done, I've rewritten it as negation to condition from
AutofillManager::ShouldUploadForm

+       (!all_fields_are_passwords() &&
+        active_field_count() < kRequiredFieldsForPredictionRoutines)) &&
       !has_author_specified_types_) {
     return false;
   }
 
   // Rule out http(s)://*/search?...
   //  e.g. http://www.google.com/search?q=...
   //       http://search.yahoo.com/search?p=...
   if (target_url_.path() == "/search")
     return false;
 
@@ skipping 699 matching lines @@
           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