[Autofill] Fill fields that have an autocomplete attributes even if not in a form.

components/autofill/core/common/form_data.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/common/form_data.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
 #include "base/base64.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/common/form_field_data.h"
 
 namespace autofill {
 
 namespace {
 
-const int kPickleVersion = 4;
+const int kPickleVersion = 5;
 
 bool ReadGURL(base::PickleIterator* iter, GURL* url) {
   std::string spec;
   if (!iter->ReadString(&spec))
     return false;
 
   *url = GURL(spec);
   return true;
 }
 
@@ skipping 22 matching lines @@
 }
 
 void LogDeserializationError(int version) {
   DVLOG(1) << "Could not deserialize version " << version
            << " FormData from pickle.";
 }
 
 }  // namespace
 
 FormData::FormData()
-    : is_form_tag(true) {
-}
+    : is_form_tag(true), is_syntehtic_non_checkout_form(false) {}
 
 FormData::FormData(const FormData& data)
     : name(data.name),
       origin(data.origin),
       action(data.action),
       is_form_tag(data.is_form_tag),
-      fields(data.fields) {
-}
+      is_syntehtic_non_checkout_form(data.is_syntehtic_non_checkout_form),
+      fields(data.fields) {}
 
 FormData::~FormData() {
 }
 
 bool FormData::SameFormAs(const FormData& form) const {
-  if (name != form.name ||
-      origin != form.origin ||
-      action != form.action ||
+  if (name != form.name || origin != form.origin || action != form.action ||
       is_form_tag != form.is_form_tag ||
+      is_syntehtic_non_checkout_form != form.is_syntehtic_non_checkout_form ||
       fields.size() != form.fields.size())
     return false;
   for (size_t i = 0; i < fields.size(); ++i) {
     if (!fields[i].SameFieldAs(form.fields[i]))
       return false;
   }
   return true;
 }
 
 bool FormData::operator<(const FormData& form) const {
-  return std::tie(name, origin, action, is_form_tag, fields) <
+  return std::tie(name, origin, action, is_form_tag,
+                  is_syntehtic_non_checkout_form, fields) <
          std::tie(form.name, form.origin, form.action, form.is_form_tag,
-                  form.fields);
+                  form.is_syntehtic_non_checkout_form, form.fields);
 }
 
 std::ostream& operator<<(std::ostream& os, const FormData& form) {
-  os << base::UTF16ToUTF8(form.name) << " "
-     << form.origin << " "
-     << form.action << " "
-     << form.is_form_tag << " "
+  os << base::UTF16ToUTF8(form.name) << " " << form.origin << " " << form.action
+     << " " << form.is_form_tag << " " << form.is_syntehtic_non_checkout_form
+     << " "
      << "Fields:";
   for (size_t i = 0; i < form.fields.size(); ++i) {
     os << form.fields[i] << ",";
   }
   return os;
 }
 
 void SerializeFormData(const FormData& form_data, base::Pickle* pickle) {
   pickle->WriteInt(kPickleVersion);
   pickle->WriteString16(form_data.name);
   pickle->WriteString(form_data.origin.spec());
   pickle->WriteString(form_data.action.spec());
   SerializeFormFieldDataVector(form_data.fields, pickle);
   pickle->WriteBool(form_data.is_form_tag);
+  pickle->WriteBool(form_data.is_syntehtic_non_checkout_form);
 }
 
 void SerializeFormDataToBase64String(const FormData& form_data,
                                      std::string* output) {
   base::Pickle pickle;
   SerializeFormData(form_data, &pickle);
   Base64Encode(
       base::StringPiece(static_cast<const char*>(pickle.data()), pickle.size()),
       output);
 }
@@ skipping 36 matching lines @@
 
   if (version >= 3) {
     if (!iter->ReadBool(&temp_form_data.is_form_tag)) {
       LogDeserializationError(version);
       return false;
     }
   } else {
     form_data->is_form_tag = true;
   }
 
+  if (version >= 5) {
+    if (!iter->ReadBool(&temp_form_data.is_syntehtic_non_checkout_form)) {
+      LogDeserializationError(version);
+      return false;
+    }
+  }
+
   *form_data = temp_form_data;
   return true;
 }
 
 bool DeserializeFormDataFromBase64String(const base::StringPiece& input,
                                          FormData* form_data) {
   if (input.empty())
     return false;
   std::string pickle_data;
   Base64Decode(input, &pickle_data);
   base::Pickle pickle(pickle_data.data(), static_cast<int>(pickle_data.size()));
   base::PickleIterator iter(pickle);
   return DeserializeFormData(&iter, form_data);
 }
 
 }  // namespace autofill