| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2010 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 "chrome/common/common_param_traits.h" | |
| 6 | |
| 7 #define IPC_MESSAGE_IMPL | |
| 8 #include "chrome/common/indexed_db_messages.h" | |
| 9 | |
| 10 IndexedDBHostMsg_FactoryOpen_Params::IndexedDBHostMsg_FactoryOpen_Params() | |
| 11 : routing_id(0), | |
| 12 response_id(0), | |
| 13 maximum_size(0) { | |
| 14 } | |
| 15 | |
| 16 IndexedDBHostMsg_FactoryOpen_Params::~IndexedDBHostMsg_FactoryOpen_Params() { | |
| 17 } | |
| 18 | |
| 19 IndexedDBHostMsg_DatabaseCreateObjectStore_Params:: | |
| 20 IndexedDBHostMsg_DatabaseCreateObjectStore_Params() | |
| 21 : auto_increment(false), | |
| 22 transaction_id(0), | |
| 23 idb_database_id(0) { | |
| 24 } | |
| 25 | |
| 26 IndexedDBHostMsg_DatabaseCreateObjectStore_Params:: | |
| 27 ~IndexedDBHostMsg_DatabaseCreateObjectStore_Params() { | |
| 28 } | |
| 29 | |
| 30 IndexedDBHostMsg_IndexOpenCursor_Params:: | |
| 31 IndexedDBHostMsg_IndexOpenCursor_Params() | |
| 32 : response_id(0), | |
| 33 lower_open(false), | |
| 34 upper_open(false), | |
| 35 direction(0), | |
| 36 idb_index_id(0), | |
| 37 transaction_id(0) { | |
| 38 } | |
| 39 | |
| 40 IndexedDBHostMsg_IndexOpenCursor_Params:: | |
| 41 ~IndexedDBHostMsg_IndexOpenCursor_Params() { | |
| 42 } | |
| 43 | |
| 44 | |
| 45 IndexedDBHostMsg_ObjectStorePut_Params:: | |
| 46 IndexedDBHostMsg_ObjectStorePut_Params() | |
| 47 : idb_object_store_id(0), | |
| 48 response_id(0), | |
| 49 add_only(false), | |
| 50 transaction_id(0) { | |
| 51 } | |
| 52 | |
| 53 IndexedDBHostMsg_ObjectStorePut_Params:: | |
| 54 ~IndexedDBHostMsg_ObjectStorePut_Params() { | |
| 55 } | |
| 56 | |
| 57 IndexedDBHostMsg_ObjectStoreCreateIndex_Params:: | |
| 58 IndexedDBHostMsg_ObjectStoreCreateIndex_Params() | |
| 59 : unique(false), | |
| 60 transaction_id(0), | |
| 61 idb_object_store_id(0) { | |
| 62 } | |
| 63 | |
| 64 IndexedDBHostMsg_ObjectStoreCreateIndex_Params:: | |
| 65 ~IndexedDBHostMsg_ObjectStoreCreateIndex_Params() { | |
| 66 } | |
| 67 | |
| 68 | |
| 69 IndexedDBHostMsg_ObjectStoreOpenCursor_Params:: | |
| 70 IndexedDBHostMsg_ObjectStoreOpenCursor_Params() | |
| 71 : response_id(0), | |
| 72 lower_open(false), | |
| 73 upper_open(false), | |
| 74 direction(0), | |
| 75 idb_object_store_id(0), | |
| 76 transaction_id(0) { | |
| 77 } | |
| 78 | |
| 79 IndexedDBHostMsg_ObjectStoreOpenCursor_Params:: | |
| 80 ~IndexedDBHostMsg_ObjectStoreOpenCursor_Params() { | |
| 81 } | |
| 82 | |
| 83 namespace IPC { | |
| 84 | |
| 85 void ParamTraits<IndexedDBHostMsg_FactoryOpen_Params>::Write( | |
| 86 Message* m, | |
| 87 const param_type& p) { | |
| 88 WriteParam(m, p.routing_id); | |
| 89 WriteParam(m, p.response_id); | |
| 90 WriteParam(m, p.origin); | |
| 91 WriteParam(m, p.name); | |
| 92 WriteParam(m, p.maximum_size); | |
| 93 } | |
| 94 | |
| 95 bool ParamTraits<IndexedDBHostMsg_FactoryOpen_Params>::Read(const Message* m, | |
| 96 void** iter, | |
| 97 param_type* p) { | |
| 98 return | |
| 99 ReadParam(m, iter, &p->routing_id) && | |
| 100 ReadParam(m, iter, &p->response_id) && | |
| 101 ReadParam(m, iter, &p->origin) && | |
| 102 ReadParam(m, iter, &p->name) && | |
| 103 ReadParam(m, iter, &p->maximum_size); | |
| 104 } | |
| 105 | |
| 106 void ParamTraits<IndexedDBHostMsg_FactoryOpen_Params>::Log(const param_type& p, | |
| 107 std::string* l) { | |
| 108 l->append("("); | |
| 109 LogParam(p.routing_id, l); | |
| 110 l->append(", "); | |
| 111 LogParam(p.response_id, l); | |
| 112 l->append(", "); | |
| 113 LogParam(p.origin, l); | |
| 114 l->append(", "); | |
| 115 LogParam(p.name, l); | |
| 116 l->append(", "); | |
| 117 LogParam(p.maximum_size, l); | |
| 118 l->append(")"); | |
| 119 } | |
| 120 | |
| 121 void ParamTraits<IndexedDBHostMsg_DatabaseCreateObjectStore_Params>::Write( | |
| 122 Message* m, | |
| 123 const param_type& p) { | |
| 124 WriteParam(m, p.name); | |
| 125 WriteParam(m, p.key_path); | |
| 126 WriteParam(m, p.auto_increment); | |
| 127 WriteParam(m, p.transaction_id); | |
| 128 WriteParam(m, p.idb_database_id); | |
| 129 } | |
| 130 | |
| 131 bool ParamTraits<IndexedDBHostMsg_DatabaseCreateObjectStore_Params>::Read( | |
| 132 const Message* m, | |
| 133 void** iter, | |
| 134 param_type* p) { | |
| 135 return | |
| 136 ReadParam(m, iter, &p->name) && | |
| 137 ReadParam(m, iter, &p->key_path) && | |
| 138 ReadParam(m, iter, &p->auto_increment) && | |
| 139 ReadParam(m, iter, &p->transaction_id) && | |
| 140 ReadParam(m, iter, &p->idb_database_id); | |
| 141 } | |
| 142 | |
| 143 void ParamTraits<IndexedDBHostMsg_DatabaseCreateObjectStore_Params>::Log( | |
| 144 const param_type& p, | |
| 145 std::string* l) { | |
| 146 l->append("("); | |
| 147 LogParam(p.name, l); | |
| 148 l->append(", "); | |
| 149 LogParam(p.key_path, l); | |
| 150 l->append(", "); | |
| 151 LogParam(p.auto_increment, l); | |
| 152 l->append(", "); | |
| 153 LogParam(p.transaction_id, l); | |
| 154 l->append(", "); | |
| 155 LogParam(p.idb_database_id, l); | |
| 156 l->append(")"); | |
| 157 } | |
| 158 | |
| 159 void ParamTraits<IndexedDBHostMsg_IndexOpenCursor_Params>::Write( | |
| 160 Message* m, | |
| 161 const param_type& p) { | |
| 162 WriteParam(m, p.response_id); | |
| 163 WriteParam(m, p.lower_key); | |
| 164 WriteParam(m, p.upper_key); | |
| 165 WriteParam(m, p.lower_open); | |
| 166 WriteParam(m, p.upper_open); | |
| 167 WriteParam(m, p.direction); | |
| 168 WriteParam(m, p.idb_index_id); | |
| 169 WriteParam(m, p.transaction_id); | |
| 170 } | |
| 171 | |
| 172 bool ParamTraits<IndexedDBHostMsg_IndexOpenCursor_Params>::Read( | |
| 173 const Message* m, | |
| 174 void** iter, | |
| 175 param_type* p) { | |
| 176 return | |
| 177 ReadParam(m, iter, &p->response_id) && | |
| 178 ReadParam(m, iter, &p->lower_key) && | |
| 179 ReadParam(m, iter, &p->upper_key) && | |
| 180 ReadParam(m, iter, &p->lower_open) && | |
| 181 ReadParam(m, iter, &p->upper_open) && | |
| 182 ReadParam(m, iter, &p->direction) && | |
| 183 ReadParam(m, iter, &p->idb_index_id) && | |
| 184 ReadParam(m, iter, &p->transaction_id); | |
| 185 } | |
| 186 | |
| 187 void ParamTraits<IndexedDBHostMsg_IndexOpenCursor_Params>::Log( | |
| 188 const param_type& p, | |
| 189 std::string* l) { | |
| 190 l->append("("); | |
| 191 LogParam(p.response_id, l); | |
| 192 l->append(", "); | |
| 193 LogParam(p.lower_key, l); | |
| 194 l->append(", "); | |
| 195 LogParam(p.upper_key, l); | |
| 196 l->append(", "); | |
| 197 LogParam(p.lower_open, l); | |
| 198 l->append(", "); | |
| 199 LogParam(p.upper_open, l); | |
| 200 l->append(", "); | |
| 201 LogParam(p.direction, l); | |
| 202 l->append(", "); | |
| 203 LogParam(p.idb_index_id, l); | |
| 204 l->append(","); | |
| 205 LogParam(p.transaction_id, l); | |
| 206 l->append(")"); | |
| 207 } | |
| 208 | |
| 209 void ParamTraits<IndexedDBHostMsg_ObjectStorePut_Params>::Write( | |
| 210 Message* m, | |
| 211 const param_type& p) { | |
| 212 WriteParam(m, p.idb_object_store_id); | |
| 213 WriteParam(m, p.response_id); | |
| 214 WriteParam(m, p.serialized_value); | |
| 215 WriteParam(m, p.key); | |
| 216 WriteParam(m, p.add_only); | |
| 217 WriteParam(m, p.transaction_id); | |
| 218 } | |
| 219 | |
| 220 bool ParamTraits<IndexedDBHostMsg_ObjectStorePut_Params>::Read( | |
| 221 const Message* m, | |
| 222 void** iter, | |
| 223 param_type* p) { | |
| 224 return | |
| 225 ReadParam(m, iter, &p->idb_object_store_id) && | |
| 226 ReadParam(m, iter, &p->response_id) && | |
| 227 ReadParam(m, iter, &p->serialized_value) && | |
| 228 ReadParam(m, iter, &p->key) && | |
| 229 ReadParam(m, iter, &p->add_only) && | |
| 230 ReadParam(m, iter, &p->transaction_id); | |
| 231 } | |
| 232 | |
| 233 void ParamTraits<IndexedDBHostMsg_ObjectStorePut_Params>::Log( | |
| 234 const param_type& p, | |
| 235 std::string* l) { | |
| 236 l->append("("); | |
| 237 LogParam(p.idb_object_store_id, l); | |
| 238 l->append(", "); | |
| 239 LogParam(p.response_id, l); | |
| 240 l->append(", "); | |
| 241 LogParam(p.serialized_value, l); | |
| 242 l->append(", "); | |
| 243 LogParam(p.key, l); | |
| 244 l->append(", "); | |
| 245 LogParam(p.add_only, l); | |
| 246 l->append(", "); | |
| 247 LogParam(p.transaction_id, l); | |
| 248 l->append(")"); | |
| 249 } | |
| 250 | |
| 251 void ParamTraits<IndexedDBHostMsg_ObjectStoreCreateIndex_Params>::Write( | |
| 252 Message* m, | |
| 253 const param_type& p) { | |
| 254 WriteParam(m, p.name); | |
| 255 WriteParam(m, p.key_path); | |
| 256 WriteParam(m, p.unique); | |
| 257 WriteParam(m, p.transaction_id); | |
| 258 WriteParam(m, p.idb_object_store_id); | |
| 259 } | |
| 260 | |
| 261 bool ParamTraits<IndexedDBHostMsg_ObjectStoreCreateIndex_Params>::Read( | |
| 262 const Message* m, | |
| 263 void** iter, | |
| 264 param_type* p) { | |
| 265 return | |
| 266 ReadParam(m, iter, &p->name) && | |
| 267 ReadParam(m, iter, &p->key_path) && | |
| 268 ReadParam(m, iter, &p->unique) && | |
| 269 ReadParam(m, iter, &p->transaction_id) && | |
| 270 ReadParam(m, iter, &p->idb_object_store_id); | |
| 271 } | |
| 272 | |
| 273 void ParamTraits<IndexedDBHostMsg_ObjectStoreCreateIndex_Params>::Log( | |
| 274 const param_type& p, | |
| 275 std::string* l) { | |
| 276 l->append("("); | |
| 277 LogParam(p.name, l); | |
| 278 l->append(", "); | |
| 279 LogParam(p.key_path, l); | |
| 280 l->append(", "); | |
| 281 LogParam(p.unique, l); | |
| 282 l->append(", "); | |
| 283 LogParam(p.transaction_id, l); | |
| 284 l->append(", "); | |
| 285 LogParam(p.idb_object_store_id, l); | |
| 286 l->append(")"); | |
| 287 } | |
| 288 | |
| 289 void ParamTraits<IndexedDBHostMsg_ObjectStoreOpenCursor_Params>::Write( | |
| 290 Message* m, | |
| 291 const param_type& p) { | |
| 292 WriteParam(m, p.response_id); | |
| 293 WriteParam(m, p.lower_key); | |
| 294 WriteParam(m, p.upper_key); | |
| 295 WriteParam(m, p.lower_open); | |
| 296 WriteParam(m, p.upper_open); | |
| 297 WriteParam(m, p.direction); | |
| 298 WriteParam(m, p.idb_object_store_id); | |
| 299 WriteParam(m, p.transaction_id); | |
| 300 } | |
| 301 | |
| 302 bool ParamTraits<IndexedDBHostMsg_ObjectStoreOpenCursor_Params>::Read( | |
| 303 const Message* m, | |
| 304 void** iter, | |
| 305 param_type* p) { | |
| 306 return | |
| 307 ReadParam(m, iter, &p->response_id) && | |
| 308 ReadParam(m, iter, &p->lower_key) && | |
| 309 ReadParam(m, iter, &p->upper_key) && | |
| 310 ReadParam(m, iter, &p->lower_open) && | |
| 311 ReadParam(m, iter, &p->upper_open) && | |
| 312 ReadParam(m, iter, &p->direction) && | |
| 313 ReadParam(m, iter, &p->idb_object_store_id) && | |
| 314 ReadParam(m, iter, &p->transaction_id); | |
| 315 } | |
| 316 | |
| 317 void ParamTraits<IndexedDBHostMsg_ObjectStoreOpenCursor_Params>::Log( | |
| 318 const param_type& p, | |
| 319 std::string* l) { | |
| 320 l->append("("); | |
| 321 LogParam(p.response_id, l); | |
| 322 l->append(", "); | |
| 323 LogParam(p.lower_key, l); | |
| 324 l->append(", "); | |
| 325 LogParam(p.upper_key, l); | |
| 326 l->append(", "); | |
| 327 LogParam(p.lower_open, l); | |
| 328 l->append(", "); | |
| 329 LogParam(p.upper_open, l); | |
| 330 l->append(", "); | |
| 331 LogParam(p.direction, l); | |
| 332 l->append(", "); | |
| 333 LogParam(p.idb_object_store_id, l); | |
| 334 l->append(","); | |
| 335 LogParam(p.transaction_id, l); | |
| 336 l->append(")"); | |
| 337 } | |
| 338 | |
| 339 } // namespace IPC | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 6410007:
Make the implementation .cc files go away, instead have the authors give us a... (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/