| OLD | NEW |
|---|
| (Empty) |
| 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 // NOTE: New trait definitions that will be used by Chrome Frame must be placed | |
| 6 // in common_param_traits2.cc. | |
| 7 | |
| 8 #include "content/public/common/webkit_param_traits.h" | |
| 9 | |
| 10 #include "base/string_number_conversions.h" | |
| 11 #include "content/public/common/common_param_traits.h" | |
| 12 #include "content/public/common/content_constants.h" | |
| 13 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h" | |
| 14 #include "webkit/forms/password_form.h" | |
| 15 #include "webkit/glue/resource_loader_bridge.h" | |
| 16 #include "webkit/plugins/npapi/plugin_host.h" | |
| 17 | |
| 18 NPIdentifier_Param::NPIdentifier_Param() | |
| 19 : identifier() { | |
| 20 } | |
| 21 | |
| 22 NPIdentifier_Param::~NPIdentifier_Param() { | |
| 23 } | |
| 24 | |
| 25 NPVariant_Param::NPVariant_Param() | |
| 26 : type(NPVARIANT_PARAM_VOID), | |
| 27 bool_value(false), | |
| 28 int_value(0), | |
| 29 double_value(0), | |
| 30 npobject_routing_id(-1) { | |
| 31 } | |
| 32 | |
| 33 NPVariant_Param::~NPVariant_Param() { | |
| 34 } | |
| 35 | |
| 36 namespace IPC { | |
| 37 | |
| 38 void ParamTraits<WebKit::WebData>::Write(Message* m, const param_type& p) { | |
| 39 if (p.isEmpty()) { | |
| 40 m->WriteData(NULL, 0); | |
| 41 } else { | |
| 42 m->WriteData(p.data(), p.size()); | |
| 43 } | |
| 44 } | |
| 45 | |
| 46 bool ParamTraits<WebKit::WebData>::Read( | |
| 47 const Message* m, PickleIterator* iter, param_type* r) { | |
| 48 const char *data = NULL; | |
| 49 int data_size = 0; | |
| 50 if (!m->ReadData(iter, &data, &data_size) || data_size < 0) | |
| 51 return false; | |
| 52 if (data_size) | |
| 53 r->assign(data, data_size); | |
| 54 else | |
| 55 r->reset(); | |
| 56 return true; | |
| 57 } | |
| 58 | |
| 59 void ParamTraits<WebKit::WebData>::Log(const param_type& p, std::string* l) { | |
| 60 l->append("(WebData of size "); | |
| 61 LogParam(p.size(), l); | |
| 62 l->append(")"); | |
| 63 } | |
| 64 | |
| 65 void ParamTraits<WebKit::WebTransformationMatrix>::Write( | |
| 66 Message* m, const param_type& p) { | |
| 67 WriteParam(m, p.m11()); | |
| 68 WriteParam(m, p.m12()); | |
| 69 WriteParam(m, p.m13()); | |
| 70 WriteParam(m, p.m14()); | |
| 71 WriteParam(m, p.m21()); | |
| 72 WriteParam(m, p.m22()); | |
| 73 WriteParam(m, p.m23()); | |
| 74 WriteParam(m, p.m24()); | |
| 75 WriteParam(m, p.m31()); | |
| 76 WriteParam(m, p.m32()); | |
| 77 WriteParam(m, p.m33()); | |
| 78 WriteParam(m, p.m34()); | |
| 79 WriteParam(m, p.m41()); | |
| 80 WriteParam(m, p.m42()); | |
| 81 WriteParam(m, p.m43()); | |
| 82 WriteParam(m, p.m44()); | |
| 83 } | |
| 84 | |
| 85 bool ParamTraits<WebKit::WebTransformationMatrix>::Read( | |
| 86 const Message* m, PickleIterator* iter, param_type* r) { | |
| 87 double m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, | |
| 88 m41, m42, m43, m44; | |
| 89 bool success = | |
| 90 ReadParam(m, iter, &m11) && | |
| 91 ReadParam(m, iter, &m12) && | |
| 92 ReadParam(m, iter, &m13) && | |
| 93 ReadParam(m, iter, &m14) && | |
| 94 ReadParam(m, iter, &m21) && | |
| 95 ReadParam(m, iter, &m22) && | |
| 96 ReadParam(m, iter, &m23) && | |
| 97 ReadParam(m, iter, &m24) && | |
| 98 ReadParam(m, iter, &m31) && | |
| 99 ReadParam(m, iter, &m32) && | |
| 100 ReadParam(m, iter, &m33) && | |
| 101 ReadParam(m, iter, &m34) && | |
| 102 ReadParam(m, iter, &m41) && | |
| 103 ReadParam(m, iter, &m42) && | |
| 104 ReadParam(m, iter, &m43) && | |
| 105 ReadParam(m, iter, &m44); | |
| 106 | |
| 107 if (success) { | |
| 108 r->setM11(m11); | |
| 109 r->setM12(m12); | |
| 110 r->setM13(m13); | |
| 111 r->setM14(m14); | |
| 112 r->setM21(m21); | |
| 113 r->setM22(m22); | |
| 114 r->setM23(m23); | |
| 115 r->setM24(m24); | |
| 116 r->setM31(m31); | |
| 117 r->setM32(m32); | |
| 118 r->setM33(m33); | |
| 119 r->setM34(m34); | |
| 120 r->setM41(m41); | |
| 121 r->setM42(m42); | |
| 122 r->setM43(m43); | |
| 123 r->setM44(m44); | |
| 124 } | |
| 125 | |
| 126 return success; | |
| 127 } | |
| 128 | |
| 129 void ParamTraits<WebKit::WebTransformationMatrix>::Log( | |
| 130 const param_type& p, std::string* l) { | |
| 131 l->append("("); | |
| 132 LogParam(p.m11(), l); | |
| 133 l->append(", "); | |
| 134 LogParam(p.m12(), l); | |
| 135 l->append(", "); | |
| 136 LogParam(p.m13(), l); | |
| 137 l->append(", "); | |
| 138 LogParam(p.m14(), l); | |
| 139 l->append(", "); | |
| 140 LogParam(p.m21(), l); | |
| 141 l->append(", "); | |
| 142 LogParam(p.m22(), l); | |
| 143 l->append(", "); | |
| 144 LogParam(p.m23(), l); | |
| 145 l->append(", "); | |
| 146 LogParam(p.m24(), l); | |
| 147 l->append(", "); | |
| 148 LogParam(p.m31(), l); | |
| 149 l->append(", "); | |
| 150 LogParam(p.m32(), l); | |
| 151 l->append(", "); | |
| 152 LogParam(p.m33(), l); | |
| 153 l->append(", "); | |
| 154 LogParam(p.m34(), l); | |
| 155 l->append(", "); | |
| 156 LogParam(p.m41(), l); | |
| 157 l->append(", "); | |
| 158 LogParam(p.m42(), l); | |
| 159 l->append(", "); | |
| 160 LogParam(p.m43(), l); | |
| 161 l->append(", "); | |
| 162 LogParam(p.m44(), l); | |
| 163 l->append(") "); | |
| 164 } | |
| 165 | |
| 166 void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Write( | |
| 167 Message* m, const param_type& p) { | |
| 168 WriteParam(m, p.base_time.is_null()); | |
| 169 if (p.base_time.is_null()) | |
| 170 return; | |
| 171 WriteParam(m, p.base_ticks); | |
| 172 WriteParam(m, p.base_time); | |
| 173 WriteParam(m, p.proxy_start); | |
| 174 WriteParam(m, p.proxy_end); | |
| 175 WriteParam(m, p.dns_start); | |
| 176 WriteParam(m, p.dns_end); | |
| 177 WriteParam(m, p.connect_start); | |
| 178 WriteParam(m, p.connect_end); | |
| 179 WriteParam(m, p.ssl_start); | |
| 180 WriteParam(m, p.ssl_end); | |
| 181 WriteParam(m, p.send_start); | |
| 182 WriteParam(m, p.send_end); | |
| 183 WriteParam(m, p.receive_headers_start); | |
| 184 WriteParam(m, p.receive_headers_end); | |
| 185 } | |
| 186 | |
| 187 bool ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Read( | |
| 188 const Message* m, PickleIterator* iter, param_type* r) { | |
| 189 bool is_null; | |
| 190 if (!ReadParam(m, iter, &is_null)) | |
| 191 return false; | |
| 192 if (is_null) | |
| 193 return true; | |
| 194 | |
| 195 return | |
| 196 ReadParam(m, iter, &r->base_ticks) && | |
| 197 ReadParam(m, iter, &r->base_time) && | |
| 198 ReadParam(m, iter, &r->proxy_start) && | |
| 199 ReadParam(m, iter, &r->proxy_end) && | |
| 200 ReadParam(m, iter, &r->dns_start) && | |
| 201 ReadParam(m, iter, &r->dns_end) && | |
| 202 ReadParam(m, iter, &r->connect_start) && | |
| 203 ReadParam(m, iter, &r->connect_end) && | |
| 204 ReadParam(m, iter, &r->ssl_start) && | |
| 205 ReadParam(m, iter, &r->ssl_end) && | |
| 206 ReadParam(m, iter, &r->send_start) && | |
| 207 ReadParam(m, iter, &r->send_end) && | |
| 208 ReadParam(m, iter, &r->receive_headers_start) && | |
| 209 ReadParam(m, iter, &r->receive_headers_end); | |
| 210 } | |
| 211 | |
| 212 void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Log(const param_type& p, | |
| 213 std::string* l) { | |
| 214 l->append("("); | |
| 215 LogParam(p.base_ticks, l); | |
| 216 l->append(", "); | |
| 217 LogParam(p.base_time, l); | |
| 218 l->append(", "); | |
| 219 LogParam(p.proxy_start, l); | |
| 220 l->append(", "); | |
| 221 LogParam(p.proxy_end, l); | |
| 222 l->append(", "); | |
| 223 LogParam(p.dns_start, l); | |
| 224 l->append(", "); | |
| 225 LogParam(p.dns_end, l); | |
| 226 l->append(", "); | |
| 227 LogParam(p.connect_start, l); | |
| 228 l->append(", "); | |
| 229 LogParam(p.connect_end, l); | |
| 230 l->append(", "); | |
| 231 LogParam(p.ssl_start, l); | |
| 232 l->append(", "); | |
| 233 LogParam(p.ssl_end, l); | |
| 234 l->append(", "); | |
| 235 LogParam(p.send_start, l); | |
| 236 l->append(", "); | |
| 237 LogParam(p.send_end, l); | |
| 238 l->append(", "); | |
| 239 LogParam(p.receive_headers_start, l); | |
| 240 l->append(", "); | |
| 241 LogParam(p.receive_headers_end, l); | |
| 242 l->append(")"); | |
| 243 } | |
| 244 | |
| 245 void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Write( | |
| 246 Message* m, const param_type& p) { | |
| 247 WriteParam(m, p.get() != NULL); | |
| 248 if (p.get()) { | |
| 249 WriteParam(m, p->http_status_code); | |
| 250 WriteParam(m, p->http_status_text); | |
| 251 WriteParam(m, p->request_headers); | |
| 252 WriteParam(m, p->response_headers); | |
| 253 WriteParam(m, p->request_headers_text); | |
| 254 WriteParam(m, p->response_headers_text); | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 bool ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Read( | |
| 259 const Message* m, PickleIterator* iter, param_type* r) { | |
| 260 bool has_object; | |
| 261 if (!ReadParam(m, iter, &has_object)) | |
| 262 return false; | |
| 263 if (!has_object) | |
| 264 return true; | |
| 265 *r = new webkit_glue::ResourceDevToolsInfo(); | |
| 266 return | |
| 267 ReadParam(m, iter, &(*r)->http_status_code) && | |
| 268 ReadParam(m, iter, &(*r)->http_status_text) && | |
| 269 ReadParam(m, iter, &(*r)->request_headers) && | |
| 270 ReadParam(m, iter, &(*r)->response_headers) && | |
| 271 ReadParam(m, iter, &(*r)->request_headers_text) && | |
| 272 ReadParam(m, iter, &(*r)->response_headers_text); | |
| 273 } | |
| 274 | |
| 275 void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Log( | |
| 276 const param_type& p, std::string* l) { | |
| 277 l->append("("); | |
| 278 if (p) { | |
| 279 LogParam(p->request_headers, l); | |
| 280 l->append(", "); | |
| 281 LogParam(p->response_headers, l); | |
| 282 } | |
| 283 l->append(")"); | |
| 284 } | |
| 285 | |
| 286 void ParamTraits<NPVariant_Param>::Write(Message* m, const param_type& p) { | |
| 287 WriteParam(m, static_cast<int>(p.type)); | |
| 288 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 289 WriteParam(m, p.bool_value); | |
| 290 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 291 WriteParam(m, p.int_value); | |
| 292 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 293 WriteParam(m, p.double_value); | |
| 294 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 295 WriteParam(m, p.string_value); | |
| 296 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 297 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 298 // This is the routing id used to connect NPObjectProxy in the other | |
| 299 // process with NPObjectStub in this process or to identify the raw | |
| 300 // npobject pointer to be used in the callee process. | |
| 301 WriteParam(m, p.npobject_routing_id); | |
| 302 } else { | |
| 303 DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL); | |
| 304 } | |
| 305 } | |
| 306 | |
| 307 bool ParamTraits<NPVariant_Param>::Read(const Message* m, | |
| 308 PickleIterator* iter, | |
| 309 param_type* r) { | |
| 310 int type; | |
| 311 if (!ReadParam(m, iter, &type)) | |
| 312 return false; | |
| 313 | |
| 314 bool result = false; | |
| 315 r->type = static_cast<NPVariant_ParamEnum>(type); | |
| 316 if (r->type == NPVARIANT_PARAM_BOOL) { | |
| 317 result = ReadParam(m, iter, &r->bool_value); | |
| 318 } else if (r->type == NPVARIANT_PARAM_INT) { | |
| 319 result = ReadParam(m, iter, &r->int_value); | |
| 320 } else if (r->type == NPVARIANT_PARAM_DOUBLE) { | |
| 321 result = ReadParam(m, iter, &r->double_value); | |
| 322 } else if (r->type == NPVARIANT_PARAM_STRING) { | |
| 323 result = ReadParam(m, iter, &r->string_value); | |
| 324 } else if (r->type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 325 r->type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 326 result = ReadParam(m, iter, &r->npobject_routing_id); | |
| 327 } else if ((r->type == NPVARIANT_PARAM_VOID) || | |
| 328 (r->type == NPVARIANT_PARAM_NULL)) { | |
| 329 result = true; | |
| 330 } else { | |
| 331 NOTREACHED(); | |
| 332 } | |
| 333 | |
| 334 return result; | |
| 335 } | |
| 336 | |
| 337 void ParamTraits<NPVariant_Param>::Log(const param_type& p, std::string* l) { | |
| 338 l->append(StringPrintf("NPVariant_Param(%d, ", static_cast<int>(p.type))); | |
| 339 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 340 LogParam(p.bool_value, l); | |
| 341 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 342 LogParam(p.int_value, l); | |
| 343 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 344 LogParam(p.double_value, l); | |
| 345 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 346 LogParam(p.string_value, l); | |
| 347 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 348 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 349 LogParam(p.npobject_routing_id, l); | |
| 350 } else { | |
| 351 l->append("<none>"); | |
| 352 } | |
| 353 l->append(")"); | |
| 354 } | |
| 355 | |
| 356 void ParamTraits<NPIdentifier_Param>::Write(Message* m, const param_type& p) { | |
| 357 webkit_glue::SerializeNPIdentifier(p.identifier, m); | |
| 358 } | |
| 359 | |
| 360 bool ParamTraits<NPIdentifier_Param>::Read(const Message* m, | |
| 361 PickleIterator* iter, | |
| 362 param_type* r) { | |
| 363 return webkit_glue::DeserializeNPIdentifier(iter, &r->identifier); | |
| 364 } | |
| 365 | |
| 366 void ParamTraits<NPIdentifier_Param>::Log(const param_type& p, std::string* l) { | |
| 367 if (WebKit::WebBindings::identifierIsString(p.identifier)) { | |
| 368 NPUTF8* str = WebKit::WebBindings::utf8FromIdentifier(p.identifier); | |
| 369 l->append(str); | |
| 370 webkit::npapi::PluginHost::Singleton()->host_functions()->memfree(str); | |
| 371 } else { | |
| 372 l->append(base::IntToString( | |
| 373 WebKit::WebBindings::intFromIdentifier(p.identifier))); | |
| 374 } | |
| 375 } | |
| 376 | |
| 377 void ParamTraits<webkit::WebPluginMimeType>::Write(Message* m, | |
| 378 const param_type& p) { | |
| 379 WriteParam(m, p.mime_type); | |
| 380 WriteParam(m, p.file_extensions); | |
| 381 WriteParam(m, p.description); | |
| 382 WriteParam(m, p.additional_param_names); | |
| 383 WriteParam(m, p.additional_param_values); | |
| 384 } | |
| 385 | |
| 386 bool ParamTraits<webkit::WebPluginMimeType>::Read(const Message* m, | |
| 387 PickleIterator* iter, | |
| 388 param_type* p) { | |
| 389 return | |
| 390 ReadParam(m, iter, &p->mime_type) && | |
| 391 ReadParam(m, iter, &p->file_extensions) && | |
| 392 ReadParam(m, iter, &p->description) && | |
| 393 ReadParam(m, iter, &p->additional_param_names) && | |
| 394 ReadParam(m, iter, &p->additional_param_values); | |
| 395 } | |
| 396 | |
| 397 void ParamTraits<webkit::WebPluginMimeType>::Log( | |
| 398 const param_type& p, std::string* l) { | |
| 399 l->append("("); | |
| 400 LogParam(p.mime_type, l); l->append(", "); | |
| 401 LogParam(p.file_extensions, l); l->append(", "); | |
| 402 LogParam(p.description, l); l->append(", "); | |
| 403 LogParam(p.additional_param_names, l); l->append(", "); | |
| 404 LogParam(p.additional_param_values, l); | |
| 405 l->append(")"); | |
| 406 } | |
| 407 | |
| 408 void ParamTraits<webkit::WebPluginInfo>::Write(Message* m, | |
| 409 const param_type& p) { | |
| 410 WriteParam(m, p.name); | |
| 411 WriteParam(m, p.path); | |
| 412 WriteParam(m, p.version); | |
| 413 WriteParam(m, p.desc); | |
| 414 WriteParam(m, p.mime_types); | |
| 415 WriteParam(m, p.type); | |
| 416 } | |
| 417 | |
| 418 bool ParamTraits<webkit::WebPluginInfo>::Read(const Message* m, | |
| 419 PickleIterator* iter, | |
| 420 param_type* p) { | |
| 421 return | |
| 422 ReadParam(m, iter, &p->name) && | |
| 423 ReadParam(m, iter, &p->path) && | |
| 424 ReadParam(m, iter, &p->version) && | |
| 425 ReadParam(m, iter, &p->desc) && | |
| 426 ReadParam(m, iter, &p->mime_types) && | |
| 427 ReadParam(m, iter, &p->type); | |
| 428 } | |
| 429 void ParamTraits<webkit::WebPluginInfo>::Log(const param_type& p, | |
| 430 std::string* l) { | |
| 431 l->append("("); | |
| 432 LogParam(p.name, l); l->append(", "); | |
| 433 LogParam(p.path, l); l->append(", "); | |
| 434 LogParam(p.version, l); l->append(", "); | |
| 435 LogParam(p.desc, l); l->append(", "); | |
| 436 LogParam(p.mime_types, l); l->append(", "); | |
| 437 LogParam(p.type, l); | |
| 438 l->append(")"); | |
| 439 } | |
| 440 | |
| 441 void ParamTraits<webkit::forms::PasswordForm>::Write(Message* m, | |
| 442 const param_type& p) { | |
| 443 WriteParam(m, p.signon_realm); | |
| 444 WriteParam(m, p.origin); | |
| 445 WriteParam(m, p.action); | |
| 446 WriteParam(m, p.submit_element); | |
| 447 WriteParam(m, p.username_element); | |
| 448 WriteParam(m, p.username_value); | |
| 449 WriteParam(m, p.password_element); | |
| 450 WriteParam(m, p.password_value); | |
| 451 WriteParam(m, p.old_password_element); | |
| 452 WriteParam(m, p.old_password_value); | |
| 453 WriteParam(m, p.ssl_valid); | |
| 454 WriteParam(m, p.preferred); | |
| 455 WriteParam(m, p.blacklisted_by_user); | |
| 456 } | |
| 457 | |
| 458 bool ParamTraits<webkit::forms::PasswordForm>::Read(const Message* m, | |
| 459 PickleIterator* iter, | |
| 460 param_type* p) { | |
| 461 return | |
| 462 ReadParam(m, iter, &p->signon_realm) && | |
| 463 ReadParam(m, iter, &p->origin) && | |
| 464 ReadParam(m, iter, &p->action) && | |
| 465 ReadParam(m, iter, &p->submit_element) && | |
| 466 ReadParam(m, iter, &p->username_element) && | |
| 467 ReadParam(m, iter, &p->username_value) && | |
| 468 ReadParam(m, iter, &p->password_element) && | |
| 469 ReadParam(m, iter, &p->password_value) && | |
| 470 ReadParam(m, iter, &p->old_password_element) && | |
| 471 ReadParam(m, iter, &p->old_password_value) && | |
| 472 ReadParam(m, iter, &p->ssl_valid) && | |
| 473 ReadParam(m, iter, &p->preferred) && | |
| 474 ReadParam(m, iter, &p->blacklisted_by_user); | |
| 475 } | |
| 476 void ParamTraits<webkit::forms::PasswordForm>::Log(const param_type& p, | |
| 477 std::string* l) { | |
| 478 l->append("<PasswordForm>"); | |
| 479 } | |
| 480 | |
| 481 } // namespace IPC | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10980010:
Cleanup the IPC param traits structure (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/