[password autofill] Add serialization for FormData and FormFieldData

components/autofill/core/common/form_field_data.cc

Index: components/autofill/core/common/form_field_data.cc
diff --git a/components/autofill/core/common/form_field_data.cc b/components/autofill/core/common/form_field_data.cc
index 1de786dcf3ca65b59ac429cc2f400000fdfdbb4f..afa9f53e0bc691f3df6b314583e3231307c7f5ab 100644
--- a/components/autofill/core/common/form_field_data.cc
+++ b/components/autofill/core/common/form_field_data.cc
@@ -4,9 +4,59 @@
 
 #include "components/autofill/core/common/form_field_data.h"
 
+#include "base/pickle.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 
+namespace {
+
+const int kPickleVersion = 1;
+
+void AddVectorToPickle(std::vector<base::string16> strings,
+                       Pickle* pickle) {
+  pickle->WriteInt(static_cast<int>(strings.size()));
+  for (size_t i = 0; i < strings.size(); ++i) {
+    pickle->WriteString16(strings[i]);
+  }
+}
+
+bool ReadStringVector(PickleIterator* iter,
+                      std::vector<base::string16>* strings) {
+  int size;
+  if (!iter->ReadInt(&size))
+    return false;
+
+  string16 pickle_data;
+  for (int i = 0; i < size; i++) {
+    if (!iter->ReadString16(&pickle_data))
+      return false;
+
+    strings->push_back(pickle_data);
+  }
+  return true;
+}
+
+bool ReadTextDirection(PickleIterator* iter,
+                       base::i18n::TextDirection* direction) {
+  int pickle_data;
+  if (!iter->ReadInt(&pickle_data))
+    return false;
+
+  *direction = static_cast<base::i18n::TextDirection>(pickle_data);
+  return true;
+}
+
+bool ReadSize(PickleIterator* iter, size_t* size) {
+  uint64 pickle_data;
+  if (!iter->ReadUInt64(&pickle_data))
+    return false;
+
+  *size = static_cast<size_t>(pickle_data);
+  return true;
+}
+
+}  // namespace
+
 namespace autofill {
 
 FormFieldData::FormFieldData()
@@ -43,6 +93,62 @@ bool FormFieldData::operator<(const FormFieldData& field) const {
   return label < field.label;
 }
 
+void SerializeFormFieldData(const FormFieldData& field_data,
+                            Pickle* pickle) {
+  pickle->WriteInt(kPickleVersion);
+  pickle->WriteString16(field_data.label);
+  pickle->WriteString16(field_data.name);
+  pickle->WriteString16(field_data.value);
+  pickle->WriteString(field_data.form_control_type);
+  pickle->WriteString(field_data.autocomplete_attribute);
+  pickle->WriteUInt64(static_cast<uint64>(field_data.max_length));
+  pickle->WriteBool(field_data.is_autofilled);
+  pickle->WriteBool(field_data.is_checked);
+  pickle->WriteBool(field_data.is_checkable);
+  pickle->WriteBool(field_data.is_focusable);
+  pickle->WriteBool(field_data.should_autocomplete);
+  pickle->WriteInt(field_data.text_direction);
+  AddVectorToPickle(field_data.option_values, pickle);
+  AddVectorToPickle(field_data.option_contents, pickle);
+}
+
+bool DeserializeFormFieldData(PickleIterator* iter,
+                              FormFieldData* field_data) {
+  int version;
+  if (!iter->ReadInt(&version)) {
+    LOG(ERROR) << "Bad pickle of FormFieldData, no version present";
+    return false;
+  }
+
+  switch (version) {
+    case 1: {
+      if (!iter->ReadString16(&field_data->label) ||
+          !iter->ReadString16(&field_data->name) ||
+          !iter->ReadString16(&field_data->value) ||
+          !iter->ReadString(&field_data->form_control_type) ||
+          !iter->ReadString(&field_data->autocomplete_attribute) ||
+          !ReadSize(iter, &field_data->max_length) ||
+          !iter->ReadBool(&field_data->is_autofilled) ||
+          !iter->ReadBool(&field_data->is_checked) ||
+          !iter->ReadBool(&field_data->is_checkable) ||
+          !iter->ReadBool(&field_data->is_focusable) ||
+          !iter->ReadBool(&field_data->should_autocomplete) ||
+          !ReadTextDirection(iter, &field_data->text_direction) ||
+          !ReadStringVector(iter, &field_data->option_values) ||
+          !ReadStringVector(iter, &field_data->option_contents)) {
+        LOG(ERROR) << "Could not deserialize FormFieldData from pickle";
+        return false;
+      }
+      break;
+    }
+    default: {
+      LOG(ERROR) << "Unknown FormFieldData pickle version " << version;
+      return false;
+    }
+  }
+  return true;
+}
+
 std::ostream& operator<<(std::ostream& os, const FormFieldData& field) {
   return os
       << UTF16ToUTF8(field.label)