Update To 11.40.268.0
[platform/framework/web/crosswalk.git] / 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