src/components/autofill/core/common/form_field_data.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/autofill/core/common/form_field_data.h"
   6
   7 #include "base/pickle.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10
  11 namespace {
  12
  13 const int kPickleVersion = 1;
  14
  15 void AddVectorToPickle(std::vector<base::string16> strings,
  16                        Pickle* pickle) {
  17   pickle->WriteInt(static_cast<int>(strings.size()));
  18   for (size_t i = 0; i < strings.size(); ++i) {
  19     pickle->WriteString16(strings[i]);
  20   }
  21 }
  22
  23 bool ReadStringVector(PickleIterator* iter,
  24                       std::vector<base::string16>* strings) {
  25   int size;
  26   if (!iter->ReadInt(&size))
  27     return false;
  28
  29   base::string16 pickle_data;
  30   for (int i = 0; i < size; i++) {
  31     if (!iter->ReadString16(&pickle_data))
  32       return false;
  33
  34     strings->push_back(pickle_data);
  35   }
  36   return true;
  37 }
  38
  39 bool ReadTextDirection(PickleIterator* iter,
  40                        base::i18n::TextDirection* direction) {
  41   int pickle_data;
  42   if (!iter->ReadInt(&pickle_data))
  43     return false;
  44
  45   *direction = static_cast<base::i18n::TextDirection>(pickle_data);
  46   return true;
  47 }
  48
  49 }  // namespace
  50
  51 namespace autofill {
  52
  53 FormFieldData::FormFieldData()
  54     : max_length(0),
  55       is_autofilled(false),
  56       is_checked(false),
  57       is_checkable(false),
  58       is_focusable(false),
  59       should_autocomplete(true),
  60       text_direction(base::i18n::UNKNOWN_DIRECTION) {
  61 }
  62
  63 FormFieldData::~FormFieldData() {
  64 }
  65
  66 bool FormFieldData::operator==(const FormFieldData& field) const {
  67   // A FormFieldData stores a value, but the value is not part of the identity
  68   // of the field, so we don't want to compare the values.
  69   return (label == field.label &&
  70           name == field.name &&
  71           form_control_type == field.form_control_type &&
  72           autocomplete_attribute == field.autocomplete_attribute &&
  73           max_length == field.max_length);
  74 }
  75
  76 bool FormFieldData::operator!=(const FormFieldData& field) const {
  77   return !operator==(field);
  78 }
  79
  80 bool FormFieldData::operator<(const FormFieldData& field) const {
  81   if (label == field.label)
  82     return name < field.name;
  83
  84   return label < field.label;
  85 }
  86
  87 void SerializeFormFieldData(const FormFieldData& field_data,
  88                             Pickle* pickle) {
  89   pickle->WriteInt(kPickleVersion);
  90   pickle->WriteString16(field_data.label);
  91   pickle->WriteString16(field_data.name);
  92   pickle->WriteString16(field_data.value);
  93   pickle->WriteString(field_data.form_control_type);
  94   pickle->WriteString(field_data.autocomplete_attribute);
  95   pickle->WriteSizeT(field_data.max_length);
  96   pickle->WriteBool(field_data.is_autofilled);
  97   pickle->WriteBool(field_data.is_checked);
  98   pickle->WriteBool(field_data.is_checkable);
  99   pickle->WriteBool(field_data.is_focusable);
 100   pickle->WriteBool(field_data.should_autocomplete);
 101   pickle->WriteInt(field_data.text_direction);
 102   AddVectorToPickle(field_data.option_values, pickle);
 103   AddVectorToPickle(field_data.option_contents, pickle);
 104 }
 105
 106 bool DeserializeFormFieldData(PickleIterator* iter,
 107                               FormFieldData* field_data) {
 108   int version;
 109   if (!iter->ReadInt(&version)) {
 110     LOG(ERROR) << "Bad pickle of FormFieldData, no version present";
 111     return false;
 112   }
 113
 114   switch (version) {
 115     case 1: {
 116       if (!iter->ReadString16(&field_data->label) ||
 117           !iter->ReadString16(&field_data->name) ||
 118           !iter->ReadString16(&field_data->value) ||
 119           !iter->ReadString(&field_data->form_control_type) ||
 120           !iter->ReadString(&field_data->autocomplete_attribute) ||
 121           !iter->ReadSizeT(&field_data->max_length) ||
 122           !iter->ReadBool(&field_data->is_autofilled) ||
 123           !iter->ReadBool(&field_data->is_checked) ||
 124           !iter->ReadBool(&field_data->is_checkable) ||
 125           !iter->ReadBool(&field_data->is_focusable) ||
 126           !iter->ReadBool(&field_data->should_autocomplete) ||
 127           !ReadTextDirection(iter, &field_data->text_direction) ||
 128           !ReadStringVector(iter, &field_data->option_values) ||
 129           !ReadStringVector(iter, &field_data->option_contents)) {
 130         LOG(ERROR) << "Could not deserialize FormFieldData from pickle";
 131         return false;
 132       }
 133       break;
 134     }
 135     default: {
 136       LOG(ERROR) << "Unknown FormFieldData pickle version " << version;
 137       return false;
 138     }
 139   }
 140   return true;
 141 }
 142
 143 std::ostream& operator<<(std::ostream& os, const FormFieldData& field) {
 144   return os
 145       << base::UTF16ToUTF8(field.label)
 146       << " "
 147       << base::UTF16ToUTF8(field.name)
 148       << " "
 149       << base::UTF16ToUTF8(field.value)
 150       << " "
 151       << field.form_control_type
 152       << " "
 153       << field.autocomplete_attribute
 154       << " "
 155       << field.max_length
 156       << " "
 157       << (field.is_autofilled ? "true" : "false")
 158       << " "
 159       << (field.is_checked ? "true" : "false")
 160       << " "
 161       << (field.is_checkable ? "true" : "false")
 162       << " "
 163       << (field.is_focusable ? "true" : "false")
 164       << " "
 165       << (field.should_autocomplete ? "true" : "false")
 166       << " "
 167       << field.text_direction;
 168 }
 169
 170 }  // namespace autofill