1// Copyright (c) 2012 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 "ui/base/models/menu_model.h"
6
7// Get basic type definitions.
8#define IPC_MESSAGE_IMPL
9#include "chrome/common/automation_messages.h"
10
11// Generate constructors.
12#include "ipc/struct_constructor_macros.h"
13#include "chrome/common/automation_messages.h"
14
15// Generate destructors.
16#include "ipc/struct_destructor_macros.h"
17#include "chrome/common/automation_messages.h"
18
19// Generate param traits write methods.
20#include "ipc/param_traits_write_macros.h"
21namespace IPC {
22#include "chrome/common/automation_messages.h"
23}  // namespace IPC
24
25// Generate param traits read methods.
26#include "ipc/param_traits_read_macros.h"
27namespace IPC {
28#include "chrome/common/automation_messages.h"
29}  // namespace IPC
30
31// Generate param traits log methods.
32#include "ipc/param_traits_log_macros.h"
33namespace IPC {
34#include "chrome/common/automation_messages.h"
35}  // namespace IPC
36
37ContextMenuModel::ContextMenuModel() {
38}
39
40ContextMenuModel::~ContextMenuModel() {
41  for (size_t i = 0; i < items.size(); ++i)
42    delete items[i].submenu;
43}
44
45ContextMenuModel::Item::Item()
46    : type(static_cast<int>(ui::MenuModel::TYPE_COMMAND)),
47      item_id(0),
48      checked(false),
49      enabled(true),
50      submenu(NULL) {
51}
52
53namespace IPC {
54
55void ParamTraits<ContextMenuModel>::Write(Message* m,
56                                          const param_type& p) {
57  WriteParam(m, p.items.size());
58  for (size_t i = 0; i < p.items.size(); ++i) {
59    WriteParam(m, static_cast<int>(p.items[i].type));
60    WriteParam(m, p.items[i].item_id);
61    WriteParam(m, p.items[i].label);
62    WriteParam(m, p.items[i].checked);
63    WriteParam(m, p.items[i].enabled);
64
65    if (p.items[i].type == static_cast<int>(ui::MenuModel::TYPE_SUBMENU)) {
66      Write(m, *p.items[i].submenu);
67    }
68  }
69}
70
71bool ParamTraits<ContextMenuModel>::Read(const Message* m,
72                                         PickleIterator* iter,
73                                         param_type* p) {
74  size_t item_count = 0;
75  if (!ReadParam(m, iter, &item_count))
76    return false;
77
78  p->items.reserve(item_count);
79  for (size_t i = 0; i < item_count; ++i) {
80    ContextMenuModel::Item item;
81    if (!ReadParam(m, iter, &item.type))
82      return false;
83    if (!ReadParam(m, iter, &item.item_id))
84      return false;
85    if (!ReadParam(m, iter, &item.label))
86      return false;
87    if (!ReadParam(m, iter, &item.checked))
88      return false;
89    if (!ReadParam(m, iter, &item.enabled))
90      return false;
91
92    if (item.type == static_cast<int>(ui::MenuModel::TYPE_SUBMENU)) {
93      item.submenu = new ContextMenuModel;
94      if (!Read(m, iter, item.submenu)) {
95        delete item.submenu;
96        item.submenu = NULL;
97        return false;
98      }
99    }
100
101    p->items.push_back(item);
102  }
103
104  return true;
105}
106
107void ParamTraits<ContextMenuModel>::Log(const param_type& p,
108                                        std::string* l) {
109  l->append("(");
110  for (size_t i = 0; i < p.items.size(); ++i) {
111    const ContextMenuModel::Item& item = p.items[i];
112    if (i)
113      l->append(", ");
114    l->append("(");
115    LogParam(item.type, l);
116    l->append(", ");
117    LogParam(item.item_id, l);
118    l->append(", ");
119    LogParam(item.label, l);
120    l->append(", ");
121    LogParam(item.checked, l);
122    l->append(", ");
123    LogParam(item.enabled, l);
124    if (item.type == ui::MenuModel::TYPE_SUBMENU) {
125      l->append(", ");
126      Log(*item.submenu, l);
127    }
128    l->append(")");
129  }
130  l->append(")");
131}
132
133// Only the net::UploadData ParamTraits<> definition needs this definition, so
134// keep this in the implementation file so we can forward declare UploadData in
135// the header.
136template <>
137struct ParamTraits<net::UploadElement> {
138  typedef net::UploadElement param_type;
139  static void Write(Message* m, const param_type& p) {
140    WriteParam(m, static_cast<int>(p.type()));
141    switch (p.type()) {
142      case net::UploadElement::TYPE_BYTES: {
143        m->WriteData(p.bytes(), static_cast<int>(p.bytes_length()));
144        break;
145      }
146      default: {
147        DCHECK(p.type() == net::UploadElement::TYPE_FILE);
148        WriteParam(m, p.file_path());
149        WriteParam(m, p.file_range_offset());
150        WriteParam(m, p.file_range_length());
151        WriteParam(m, p.expected_file_modification_time());
152        break;
153      }
154    }
155  }
156  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
157    int type;
158    if (!ReadParam(m, iter, &type))
159      return false;
160    switch (type) {
161      case net::UploadElement::TYPE_BYTES: {
162        const char* data;
163        int len;
164        if (!m->ReadData(iter, &data, &len))
165          return false;
166        r->SetToBytes(data, len);
167        break;
168      }
169      default: {
170        DCHECK(type == net::UploadElement::TYPE_FILE);
171        base::FilePath file_path;
172        uint64 offset, length;
173        base::Time expected_modification_time;
174        if (!ReadParam(m, iter, &file_path))
175          return false;
176        if (!ReadParam(m, iter, &offset))
177          return false;
178        if (!ReadParam(m, iter, &length))
179          return false;
180        if (!ReadParam(m, iter, &expected_modification_time))
181          return false;
182        r->SetToFilePathRange(file_path, offset, length,
183                              expected_modification_time);
184        break;
185      }
186    }
187    return true;
188  }
189  static void Log(const param_type& p, std::string* l) {
190    l->append("<net::UploadElement>");
191  }
192};
193
194void ParamTraits<scoped_refptr<net::UploadData> >::Write(Message* m,
195                                                         const param_type& p) {
196  WriteParam(m, p.get() != NULL);
197  if (p.get()) {
198    WriteParam(m, p->elements());
199    WriteParam(m, p->identifier());
200    WriteParam(m, p->is_chunked());
201    WriteParam(m, p->last_chunk_appended());
202  }
203}
204
205bool ParamTraits<scoped_refptr<net::UploadData> >::Read(const Message* m,
206                                                        PickleIterator* iter,
207                                                        param_type* r) {
208  bool has_object;
209  if (!ReadParam(m, iter, &has_object))
210    return false;
211  if (!has_object)
212    return true;
213  ScopedVector<net::UploadElement> elements;
214  if (!ReadParam(m, iter, &elements))
215    return false;
216  int64 identifier;
217  if (!ReadParam(m, iter, &identifier))
218    return false;
219  bool is_chunked = false;
220  if (!ReadParam(m, iter, &is_chunked))
221    return false;
222  bool last_chunk_appended = false;
223  if (!ReadParam(m, iter, &last_chunk_appended))
224    return false;
225  *r = new net::UploadData;
226  (*r)->swap_elements(&elements);
227  (*r)->set_identifier(identifier);
228  (*r)->set_is_chunked(is_chunked);
229  (*r)->set_last_chunk_appended(last_chunk_appended);
230  return true;
231}
232
233void ParamTraits<scoped_refptr<net::UploadData> >::Log(const param_type& p,
234                                                       std::string* l) {
235  l->append("<net::UploadData>");
236}
237
238void ParamTraits<net::URLRequestStatus>::Write(Message* m,
239                                               const param_type& p) {
240  WriteParam(m, static_cast<int>(p.status()));
241  WriteParam(m, p.error());
242}
243
244bool ParamTraits<net::URLRequestStatus>::Read(const Message* m,
245                                              PickleIterator* iter,
246                                              param_type* r) {
247  int status, error;
248  if (!ReadParam(m, iter, &status) || !ReadParam(m, iter, &error))
249    return false;
250  r->set_status(static_cast<net::URLRequestStatus::Status>(status));
251  r->set_error(error);
252  return true;
253}
254
255void ParamTraits<net::URLRequestStatus>::Log(const param_type& p,
256                                             std::string* l) {
257  std::string status;
258  switch (p.status()) {
259    case net::URLRequestStatus::SUCCESS:
260      status = "SUCCESS";
261      break;
262    case net::URLRequestStatus::IO_PENDING:
263      status = "IO_PENDING ";
264      break;
265    case net::URLRequestStatus::CANCELED:
266      status = "CANCELED";
267      break;
268    case net::URLRequestStatus::FAILED:
269      status = "FAILED";
270      break;
271    default:
272      status = "UNKNOWN";
273      break;
274  }
275  if (p.status() == net::URLRequestStatus::FAILED)
276    l->append("(");
277
278  LogParam(status, l);
279
280  if (p.status() == net::URLRequestStatus::FAILED) {
281    l->append(", ");
282    LogParam(p.error(), l);
283    l->append(")");
284  }
285}
286
287}  // namespace IPC
288