| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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/common/webkit_param_traits.h" | |
| 9 | |
| 10 #include "base/string_number_conversions.h" | |
| 11 #include "content/common/common_param_traits.h" | |
| 12 #include "content/common/content_constants.h" | |
| 13 #include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h" | |
| 14 #include "webkit/glue/password_form.h" | |
| 15 #include "webkit/glue/resource_loader_bridge.h" | |
| 16 | |
| 17 NPIdentifier_Param::NPIdentifier_Param() | |
| 18 : identifier() { | |
| 19 } | |
| 20 | |
| 21 NPIdentifier_Param::~NPIdentifier_Param() { | |
| 22 } | |
| 23 | |
| 24 NPVariant_Param::NPVariant_Param() | |
| 25 : type(NPVARIANT_PARAM_VOID), | |
| 26 bool_value(false), | |
| 27 int_value(0), | |
| 28 double_value(0), | |
| 29 npobject_routing_id(-1) { | |
| 30 } | |
| 31 | |
| 32 NPVariant_Param::~NPVariant_Param() { | |
| 33 } | |
| 34 | |
| 35 namespace IPC { | |
| 36 | |
| 37 void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Write( | |
| 38 Message* m, const param_type& p) { | |
| 39 WriteParam(m, p.base_time.is_null()); | |
| 40 if (p.base_time.is_null()) | |
| 41 return; | |
| 42 WriteParam(m, p.base_time); | |
| 43 WriteParam(m, p.proxy_start); | |
| 44 WriteParam(m, p.proxy_end); | |
| 45 WriteParam(m, p.dns_start); | |
| 46 WriteParam(m, p.dns_end); | |
| 47 WriteParam(m, p.connect_start); | |
| 48 WriteParam(m, p.connect_end); | |
| 49 WriteParam(m, p.ssl_start); | |
| 50 WriteParam(m, p.ssl_end); | |
| 51 WriteParam(m, p.send_start); | |
| 52 WriteParam(m, p.send_end); | |
| 53 WriteParam(m, p.receive_headers_start); | |
| 54 WriteParam(m, p.receive_headers_end); | |
| 55 } | |
| 56 | |
| 57 bool ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Read( | |
| 58 const Message* m, void** iter, param_type* r) { | |
| 59 bool is_null; | |
| 60 if (!ReadParam(m, iter, &is_null)) | |
| 61 return false; | |
| 62 if (is_null) | |
| 63 return true; | |
| 64 | |
| 65 return | |
| 66 ReadParam(m, iter, &r->base_time) && | |
| 67 ReadParam(m, iter, &r->proxy_start) && | |
| 68 ReadParam(m, iter, &r->proxy_end) && | |
| 69 ReadParam(m, iter, &r->dns_start) && | |
| 70 ReadParam(m, iter, &r->dns_end) && | |
| 71 ReadParam(m, iter, &r->connect_start) && | |
| 72 ReadParam(m, iter, &r->connect_end) && | |
| 73 ReadParam(m, iter, &r->ssl_start) && | |
| 74 ReadParam(m, iter, &r->ssl_end) && | |
| 75 ReadParam(m, iter, &r->send_start) && | |
| 76 ReadParam(m, iter, &r->send_end) && | |
| 77 ReadParam(m, iter, &r->receive_headers_start) && | |
| 78 ReadParam(m, iter, &r->receive_headers_end); | |
| 79 } | |
| 80 | |
| 81 void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Log(const param_type& p, | |
| 82 std::string* l) { | |
| 83 l->append("("); | |
| 84 LogParam(p.base_time, l); | |
| 85 l->append(", "); | |
| 86 LogParam(p.proxy_start, l); | |
| 87 l->append(", "); | |
| 88 LogParam(p.proxy_end, l); | |
| 89 l->append(", "); | |
| 90 LogParam(p.dns_start, l); | |
| 91 l->append(", "); | |
| 92 LogParam(p.dns_end, l); | |
| 93 l->append(", "); | |
| 94 LogParam(p.connect_start, l); | |
| 95 l->append(", "); | |
| 96 LogParam(p.connect_end, l); | |
| 97 l->append(", "); | |
| 98 LogParam(p.ssl_start, l); | |
| 99 l->append(", "); | |
| 100 LogParam(p.ssl_end, l); | |
| 101 l->append(", "); | |
| 102 LogParam(p.send_start, l); | |
| 103 l->append(", "); | |
| 104 LogParam(p.send_end, l); | |
| 105 l->append(", "); | |
| 106 LogParam(p.receive_headers_start, l); | |
| 107 l->append(", "); | |
| 108 LogParam(p.receive_headers_end, l); | |
| 109 l->append(")"); | |
| 110 } | |
| 111 | |
| 112 void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Write( | |
| 113 Message* m, const param_type& p) { | |
| 114 WriteParam(m, p.get() != NULL); | |
| 115 if (p.get()) { | |
| 116 WriteParam(m, p->http_status_code); | |
| 117 WriteParam(m, p->http_status_text); | |
| 118 WriteParam(m, p->request_headers); | |
| 119 WriteParam(m, p->response_headers); | |
| 120 WriteParam(m, p->request_headers_text); | |
| 121 WriteParam(m, p->response_headers_text); | |
| 122 } | |
| 123 } | |
| 124 | |
| 125 bool ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Read( | |
| 126 const Message* m, void** iter, param_type* r) { | |
| 127 bool has_object; | |
| 128 if (!ReadParam(m, iter, &has_object)) | |
| 129 return false; | |
| 130 if (!has_object) | |
| 131 return true; | |
| 132 *r = new webkit_glue::ResourceDevToolsInfo(); | |
| 133 return | |
| 134 ReadParam(m, iter, &(*r)->http_status_code) && | |
| 135 ReadParam(m, iter, &(*r)->http_status_text) && | |
| 136 ReadParam(m, iter, &(*r)->request_headers) && | |
| 137 ReadParam(m, iter, &(*r)->response_headers) && | |
| 138 ReadParam(m, iter, &(*r)->request_headers_text) && | |
| 139 ReadParam(m, iter, &(*r)->response_headers_text); | |
| 140 } | |
| 141 | |
| 142 void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Log( | |
| 143 const param_type& p, std::string* l) { | |
| 144 l->append("("); | |
| 145 if (p) { | |
| 146 LogParam(p->request_headers, l); | |
| 147 l->append(", "); | |
| 148 LogParam(p->response_headers, l); | |
| 149 } | |
| 150 l->append(")"); | |
| 151 } | |
| 152 | |
| 153 void ParamTraits<NPVariant_Param>::Write(Message* m, const param_type& p) { | |
| 154 WriteParam(m, static_cast<int>(p.type)); | |
| 155 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 156 WriteParam(m, p.bool_value); | |
| 157 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 158 WriteParam(m, p.int_value); | |
| 159 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 160 WriteParam(m, p.double_value); | |
| 161 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 162 WriteParam(m, p.string_value); | |
| 163 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 164 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 165 // This is the routing id used to connect NPObjectProxy in the other | |
| 166 // process with NPObjectStub in this process or to identify the raw | |
| 167 // npobject pointer to be used in the callee process. | |
| 168 WriteParam(m, p.npobject_routing_id); | |
| 169 } else { | |
| 170 DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 bool ParamTraits<NPVariant_Param>::Read(const Message* m, | |
| 175 void** iter, | |
| 176 param_type* r) { | |
| 177 int type; | |
| 178 if (!ReadParam(m, iter, &type)) | |
| 179 return false; | |
| 180 | |
| 181 bool result = false; | |
| 182 r->type = static_cast<NPVariant_ParamEnum>(type); | |
| 183 if (r->type == NPVARIANT_PARAM_BOOL) { | |
| 184 result = ReadParam(m, iter, &r->bool_value); | |
| 185 } else if (r->type == NPVARIANT_PARAM_INT) { | |
| 186 result = ReadParam(m, iter, &r->int_value); | |
| 187 } else if (r->type == NPVARIANT_PARAM_DOUBLE) { | |
| 188 result = ReadParam(m, iter, &r->double_value); | |
| 189 } else if (r->type == NPVARIANT_PARAM_STRING) { | |
| 190 result = ReadParam(m, iter, &r->string_value); | |
| 191 } else if (r->type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 192 r->type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 193 result = ReadParam(m, iter, &r->npobject_routing_id); | |
| 194 } else if ((r->type == NPVARIANT_PARAM_VOID) || | |
| 195 (r->type == NPVARIANT_PARAM_NULL)) { | |
| 196 result = true; | |
| 197 } else { | |
| 198 NOTREACHED(); | |
| 199 } | |
| 200 | |
| 201 return result; | |
| 202 } | |
| 203 | |
| 204 void ParamTraits<NPVariant_Param>::Log(const param_type& p, std::string* l) { | |
| 205 l->append(StringPrintf("NPVariant_Param(%d, ", static_cast<int>(p.type))); | |
| 206 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 207 LogParam(p.bool_value, l); | |
| 208 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 209 LogParam(p.int_value, l); | |
| 210 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 211 LogParam(p.double_value, l); | |
| 212 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 213 LogParam(p.string_value, l); | |
| 214 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 215 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 216 LogParam(p.npobject_routing_id, l); | |
| 217 } else { | |
| 218 l->append("<none>"); | |
| 219 } | |
| 220 l->append(")"); | |
| 221 } | |
| 222 | |
| 223 void ParamTraits<NPIdentifier_Param>::Write(Message* m, const param_type& p) { | |
| 224 webkit_glue::SerializeNPIdentifier(p.identifier, m); | |
| 225 } | |
| 226 | |
| 227 bool ParamTraits<NPIdentifier_Param>::Read(const Message* m, | |
| 228 void** iter, | |
| 229 param_type* r) { | |
| 230 return webkit_glue::DeserializeNPIdentifier(*m, iter, &r->identifier); | |
| 231 } | |
| 232 | |
| 233 void ParamTraits<NPIdentifier_Param>::Log(const param_type& p, std::string* l) { | |
| 234 if (WebKit::WebBindings::identifierIsString(p.identifier)) { | |
| 235 NPUTF8* str = WebKit::WebBindings::utf8FromIdentifier(p.identifier); | |
| 236 l->append(str); | |
| 237 NPN_MemFree(str); | |
| 238 } else { | |
| 239 l->append(base::IntToString( | |
| 240 WebKit::WebBindings::intFromIdentifier(p.identifier))); | |
| 241 } | |
| 242 } | |
| 243 | |
| 244 void ParamTraits<webkit::WebPluginMimeType>::Write(Message* m, | |
| 245 const param_type& p) { | |
| 246 WriteParam(m, p.mime_type); | |
| 247 WriteParam(m, p.file_extensions); | |
| 248 WriteParam(m, p.description); | |
| 249 WriteParam(m, p.additional_param_names); | |
| 250 WriteParam(m, p.additional_param_values); | |
| 251 } | |
| 252 | |
| 253 bool ParamTraits<webkit::WebPluginMimeType>::Read(const Message* m, | |
| 254 void** iter, | |
| 255 param_type* p) { | |
| 256 return | |
| 257 ReadParam(m, iter, &p->mime_type) && | |
| 258 ReadParam(m, iter, &p->file_extensions) && | |
| 259 ReadParam(m, iter, &p->description) && | |
| 260 ReadParam(m, iter, &p->additional_param_names) && | |
| 261 ReadParam(m, iter, &p->additional_param_values); | |
| 262 } | |
| 263 | |
| 264 void ParamTraits<webkit::WebPluginMimeType>::Log( | |
| 265 const param_type& p, std::string* l) { | |
| 266 l->append("("); | |
| 267 LogParam(p.mime_type, l); l->append(", "); | |
| 268 LogParam(p.file_extensions, l); l->append(", "); | |
| 269 LogParam(p.description, l); l->append(", "); | |
| 270 LogParam(p.additional_param_names, l); l->append(", "); | |
| 271 LogParam(p.additional_param_values, l); | |
| 272 l->append(")"); | |
| 273 } | |
| 274 | |
| 275 void ParamTraits<webkit::WebPluginInfo>::Write(Message* m, | |
| 276 const param_type& p) { | |
| 277 WriteParam(m, p.name); | |
| 278 WriteParam(m, p.path); | |
| 279 WriteParam(m, p.version); | |
| 280 WriteParam(m, p.desc); | |
| 281 WriteParam(m, p.mime_types); | |
| 282 WriteParam(m, p.type); | |
| 283 } | |
| 284 | |
| 285 bool ParamTraits<webkit::WebPluginInfo>::Read(const Message* m, | |
| 286 void** iter, | |
| 287 param_type* p) { | |
| 288 return | |
| 289 ReadParam(m, iter, &p->name) && | |
| 290 ReadParam(m, iter, &p->path) && | |
| 291 ReadParam(m, iter, &p->version) && | |
| 292 ReadParam(m, iter, &p->desc) && | |
| 293 ReadParam(m, iter, &p->mime_types) && | |
| 294 ReadParam(m, iter, &p->type); | |
| 295 } | |
| 296 void ParamTraits<webkit::WebPluginInfo>::Log(const param_type& p, | |
| 297 std::string* l) { | |
| 298 l->append("("); | |
| 299 LogParam(p.name, l); l->append(", "); | |
| 300 LogParam(p.path, l); l->append(", "); | |
| 301 LogParam(p.version, l); l->append(", "); | |
| 302 LogParam(p.desc, l); l->append(", "); | |
| 303 LogParam(p.mime_types, l); l->append(", "); | |
| 304 LogParam(p.type, l); | |
| 305 l->append(")"); | |
| 306 } | |
| 307 | |
| 308 void ParamTraits<webkit_glue::PasswordForm>::Write(Message* m, | |
| 309 const param_type& p) { | |
| 310 WriteParam(m, p.signon_realm); | |
| 311 WriteParam(m, p.origin); | |
| 312 WriteParam(m, p.action); | |
| 313 WriteParam(m, p.submit_element); | |
| 314 WriteParam(m, p.username_element); | |
| 315 WriteParam(m, p.username_value); | |
| 316 WriteParam(m, p.password_element); | |
| 317 WriteParam(m, p.password_value); | |
| 318 WriteParam(m, p.old_password_element); | |
| 319 WriteParam(m, p.old_password_value); | |
| 320 WriteParam(m, p.ssl_valid); | |
| 321 WriteParam(m, p.preferred); | |
| 322 WriteParam(m, p.blacklisted_by_user); | |
| 323 } | |
| 324 | |
| 325 bool ParamTraits<webkit_glue::PasswordForm>::Read(const Message* m, void** iter, | |
| 326 param_type* p) { | |
| 327 return | |
| 328 ReadParam(m, iter, &p->signon_realm) && | |
| 329 ReadParam(m, iter, &p->origin) && | |
| 330 ReadParam(m, iter, &p->action) && | |
| 331 ReadParam(m, iter, &p->submit_element) && | |
| 332 ReadParam(m, iter, &p->username_element) && | |
| 333 ReadParam(m, iter, &p->username_value) && | |
| 334 ReadParam(m, iter, &p->password_element) && | |
| 335 ReadParam(m, iter, &p->password_value) && | |
| 336 ReadParam(m, iter, &p->old_password_element) && | |
| 337 ReadParam(m, iter, &p->old_password_value) && | |
| 338 ReadParam(m, iter, &p->ssl_valid) && | |
| 339 ReadParam(m, iter, &p->preferred) && | |
| 340 ReadParam(m, iter, &p->blacklisted_by_user); | |
| 341 } | |
| 342 void ParamTraits<webkit_glue::PasswordForm>::Log(const param_type& p, | |
| 343 std::string* l) { | |
| 344 l->append("<PasswordForm>"); | |
| 345 } | |
| 346 | |
| 347 } // namespace IPC | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 8368004:
Move common_param_traits and webkit_param_traits to content/public/common. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/