| 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 "base/utf_string_conversions.h" | |
| 6 #include "content/common/common_param_traits.h" | |
| 7 #include "ipc/ipc_channel_handle.h" | |
| 8 | |
| 9 #define IPC_MESSAGE_IMPL | |
| 10 #include "chrome/common/plugin_messages.h" | |
| 11 | |
| 12 PluginMsg_Init_Params::PluginMsg_Init_Params() | |
| 13 : containing_window(0), | |
| 14 load_manually(false), | |
| 15 host_render_view_routing_id(-1) { | |
| 16 } | |
| 17 | |
| 18 PluginMsg_Init_Params::~PluginMsg_Init_Params() { | |
| 19 } | |
| 20 | |
| 21 PluginHostMsg_URLRequest_Params::PluginHostMsg_URLRequest_Params() | |
| 22 : notify_id(-1), | |
| 23 popups_allowed(false), | |
| 24 notify_redirects(false) { | |
| 25 } | |
| 26 | |
| 27 PluginHostMsg_URLRequest_Params::~PluginHostMsg_URLRequest_Params() { | |
| 28 } | |
| 29 | |
| 30 PluginMsg_DidReceiveResponseParams::PluginMsg_DidReceiveResponseParams() | |
| 31 : id(-1), | |
| 32 expected_length(0), | |
| 33 last_modified(0), | |
| 34 request_is_seekable(false) { | |
| 35 } | |
| 36 | |
| 37 PluginMsg_DidReceiveResponseParams::~PluginMsg_DidReceiveResponseParams() { | |
| 38 } | |
| 39 | |
| 40 NPIdentifier_Param::NPIdentifier_Param() | |
| 41 : identifier() { | |
| 42 } | |
| 43 | |
| 44 NPIdentifier_Param::~NPIdentifier_Param() { | |
| 45 } | |
| 46 | |
| 47 NPVariant_Param::NPVariant_Param() | |
| 48 : type(NPVARIANT_PARAM_VOID), | |
| 49 bool_value(false), | |
| 50 int_value(0), | |
| 51 double_value(0), | |
| 52 npobject_routing_id(-1) { | |
| 53 } | |
| 54 | |
| 55 NPVariant_Param::~NPVariant_Param() { | |
| 56 } | |
| 57 | |
| 58 PluginMsg_UpdateGeometry_Param::PluginMsg_UpdateGeometry_Param() | |
| 59 : transparent(false), | |
| 60 #if !defined(OS_MACOSX) | |
| 61 windowless_buffer(TransportDIB::DefaultHandleValue()), | |
| 62 background_buffer(TransportDIB::DefaultHandleValue()) | |
| 63 #else | |
| 64 ack_key(-1) | |
| 65 #endif // !defined(OS_MACOSX) | |
| 66 { | |
| 67 } | |
| 68 | |
| 69 PluginMsg_UpdateGeometry_Param::~PluginMsg_UpdateGeometry_Param() { | |
| 70 } | |
| 71 | |
| 72 namespace IPC { | |
| 73 | |
| 74 void ParamTraits<PluginMsg_Init_Params>::Write(Message* m, | |
| 75 const param_type& p) { | |
| 76 WriteParam(m, p.containing_window); | |
| 77 WriteParam(m, p.url); | |
| 78 WriteParam(m, p.page_url); | |
| 79 DCHECK(p.arg_names.size() == p.arg_values.size()); | |
| 80 WriteParam(m, p.arg_names); | |
| 81 WriteParam(m, p.arg_values); | |
| 82 WriteParam(m, p.load_manually); | |
| 83 WriteParam(m, p.host_render_view_routing_id); | |
| 84 } | |
| 85 | |
| 86 bool ParamTraits<PluginMsg_Init_Params>::Read(const Message* m, | |
| 87 void** iter, | |
| 88 param_type* p) { | |
| 89 return ReadParam(m, iter, &p->containing_window) && | |
| 90 ReadParam(m, iter, &p->url) && | |
| 91 ReadParam(m, iter, &p->page_url) && | |
| 92 ReadParam(m, iter, &p->arg_names) && | |
| 93 ReadParam(m, iter, &p->arg_values) && | |
| 94 ReadParam(m, iter, &p->load_manually) && | |
| 95 ReadParam(m, iter, &p->host_render_view_routing_id); | |
| 96 } | |
| 97 | |
| 98 void ParamTraits<PluginMsg_Init_Params>::Log(const param_type& p, | |
| 99 std::string* l) { | |
| 100 l->append("("); | |
| 101 LogParam(p.containing_window, l); | |
| 102 l->append(", "); | |
| 103 LogParam(p.url, l); | |
| 104 l->append(", "); | |
| 105 LogParam(p.page_url, l); | |
| 106 l->append(", "); | |
| 107 LogParam(p.arg_names, l); | |
| 108 l->append(", "); | |
| 109 LogParam(p.arg_values, l); | |
| 110 l->append(", "); | |
| 111 LogParam(p.load_manually, l); | |
| 112 l->append(", "); | |
| 113 LogParam(p.host_render_view_routing_id, l); | |
| 114 l->append(")"); | |
| 115 } | |
| 116 | |
| 117 void ParamTraits<PluginHostMsg_URLRequest_Params>::Write(Message* m, | |
| 118 const param_type& p) { | |
| 119 WriteParam(m, p.url); | |
| 120 WriteParam(m, p.method); | |
| 121 WriteParam(m, p.target); | |
| 122 WriteParam(m, p.buffer); | |
| 123 WriteParam(m, p.notify_id); | |
| 124 WriteParam(m, p.popups_allowed); | |
| 125 WriteParam(m, p.notify_redirects); | |
| 126 } | |
| 127 | |
| 128 bool ParamTraits<PluginHostMsg_URLRequest_Params>::Read(const Message* m, | |
| 129 void** iter, | |
| 130 param_type* p) { | |
| 131 return | |
| 132 ReadParam(m, iter, &p->url) && | |
| 133 ReadParam(m, iter, &p->method) && | |
| 134 ReadParam(m, iter, &p->target) && | |
| 135 ReadParam(m, iter, &p->buffer) && | |
| 136 ReadParam(m, iter, &p->notify_id) && | |
| 137 ReadParam(m, iter, &p->popups_allowed) && | |
| 138 ReadParam(m, iter, &p->notify_redirects); | |
| 139 } | |
| 140 | |
| 141 void ParamTraits<PluginHostMsg_URLRequest_Params>::Log(const param_type& p, | |
| 142 std::string* l) { | |
| 143 l->append("("); | |
| 144 LogParam(p.url, l); | |
| 145 l->append(", "); | |
| 146 LogParam(p.method, l); | |
| 147 l->append(", "); | |
| 148 LogParam(p.target, l); | |
| 149 l->append(", "); | |
| 150 LogParam(p.buffer, l); | |
| 151 l->append(", "); | |
| 152 LogParam(p.notify_id, l); | |
| 153 l->append(", "); | |
| 154 LogParam(p.popups_allowed, l); | |
| 155 l->append(", "); | |
| 156 LogParam(p.notify_redirects, l); | |
| 157 l->append(")"); | |
| 158 } | |
| 159 | |
| 160 | |
| 161 void ParamTraits<PluginMsg_DidReceiveResponseParams>::Write( | |
| 162 Message* m, | |
| 163 const param_type& p) { | |
| 164 WriteParam(m, p.id); | |
| 165 WriteParam(m, p.mime_type); | |
| 166 WriteParam(m, p.headers); | |
| 167 WriteParam(m, p.expected_length); | |
| 168 WriteParam(m, p.last_modified); | |
| 169 WriteParam(m, p.request_is_seekable); | |
| 170 } | |
| 171 | |
| 172 bool ParamTraits<PluginMsg_DidReceiveResponseParams>::Read(const Message* m, | |
| 173 void** iter, | |
| 174 param_type* r) { | |
| 175 return | |
| 176 ReadParam(m, iter, &r->id) && | |
| 177 ReadParam(m, iter, &r->mime_type) && | |
| 178 ReadParam(m, iter, &r->headers) && | |
| 179 ReadParam(m, iter, &r->expected_length) && | |
| 180 ReadParam(m, iter, &r->last_modified) && | |
| 181 ReadParam(m, iter, &r->request_is_seekable); | |
| 182 } | |
| 183 | |
| 184 void ParamTraits<PluginMsg_DidReceiveResponseParams>::Log(const param_type& p, | |
| 185 std::string* l) { | |
| 186 l->append("("); | |
| 187 LogParam(p.id, l); | |
| 188 l->append(", "); | |
| 189 LogParam(p.mime_type, l); | |
| 190 l->append(", "); | |
| 191 LogParam(p.headers, l); | |
| 192 l->append(", "); | |
| 193 LogParam(p.expected_length, l); | |
| 194 l->append(", "); | |
| 195 LogParam(p.last_modified, l); | |
| 196 l->append(", "); | |
| 197 LogParam(p.request_is_seekable, l); | |
| 198 l->append(")"); | |
| 199 } | |
| 200 | |
| 201 | |
| 202 void ParamTraits<NPVariant_Param>::Write(Message* m, const param_type& p) { | |
| 203 WriteParam(m, static_cast<int>(p.type)); | |
| 204 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 205 WriteParam(m, p.bool_value); | |
| 206 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 207 WriteParam(m, p.int_value); | |
| 208 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 209 WriteParam(m, p.double_value); | |
| 210 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 211 WriteParam(m, p.string_value); | |
| 212 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 213 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 214 // This is the routing id used to connect NPObjectProxy in the other | |
| 215 // process with NPObjectStub in this process or to identify the raw | |
| 216 // npobject pointer to be used in the callee process. | |
| 217 WriteParam(m, p.npobject_routing_id); | |
| 218 } else { | |
| 219 DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL); | |
| 220 } | |
| 221 } | |
| 222 | |
| 223 bool ParamTraits<NPVariant_Param>::Read(const Message* m, | |
| 224 void** iter, | |
| 225 param_type* r) { | |
| 226 int type; | |
| 227 if (!ReadParam(m, iter, &type)) | |
| 228 return false; | |
| 229 | |
| 230 bool result = false; | |
| 231 r->type = static_cast<NPVariant_ParamEnum>(type); | |
| 232 if (r->type == NPVARIANT_PARAM_BOOL) { | |
| 233 result = ReadParam(m, iter, &r->bool_value); | |
| 234 } else if (r->type == NPVARIANT_PARAM_INT) { | |
| 235 result = ReadParam(m, iter, &r->int_value); | |
| 236 } else if (r->type == NPVARIANT_PARAM_DOUBLE) { | |
| 237 result = ReadParam(m, iter, &r->double_value); | |
| 238 } else if (r->type == NPVARIANT_PARAM_STRING) { | |
| 239 result = ReadParam(m, iter, &r->string_value); | |
| 240 } else if (r->type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 241 r->type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 242 result = ReadParam(m, iter, &r->npobject_routing_id); | |
| 243 } else if ((r->type == NPVARIANT_PARAM_VOID) || | |
| 244 (r->type == NPVARIANT_PARAM_NULL)) { | |
| 245 result = true; | |
| 246 } else { | |
| 247 NOTREACHED(); | |
| 248 } | |
| 249 | |
| 250 return result; | |
| 251 } | |
| 252 | |
| 253 void ParamTraits<NPVariant_Param>::Log(const param_type& p, std::string* l) { | |
| 254 if (p.type == NPVARIANT_PARAM_BOOL) { | |
| 255 LogParam(p.bool_value, l); | |
| 256 } else if (p.type == NPVARIANT_PARAM_INT) { | |
| 257 LogParam(p.int_value, l); | |
| 258 } else if (p.type == NPVARIANT_PARAM_DOUBLE) { | |
| 259 LogParam(p.double_value, l); | |
| 260 } else if (p.type == NPVARIANT_PARAM_STRING) { | |
| 261 LogParam(p.string_value, l); | |
| 262 } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID || | |
| 263 p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) { | |
| 264 LogParam(p.npobject_routing_id, l); | |
| 265 } | |
| 266 } | |
| 267 | |
| 268 void ParamTraits<PluginMsg_UpdateGeometry_Param>::Write(Message* m, | |
| 269 const param_type& p) { | |
| 270 WriteParam(m, p.window_rect); | |
| 271 WriteParam(m, p.clip_rect); | |
| 272 WriteParam(m, p.windowless_buffer); | |
| 273 WriteParam(m, p.background_buffer); | |
| 274 WriteParam(m, p.transparent); | |
| 275 #if defined(OS_MACOSX) | |
| 276 WriteParam(m, p.ack_key); | |
| 277 #endif | |
| 278 } | |
| 279 | |
| 280 bool ParamTraits<PluginMsg_UpdateGeometry_Param>::Read(const Message* m, | |
| 281 void** iter, | |
| 282 param_type* r) { | |
| 283 return | |
| 284 ReadParam(m, iter, &r->window_rect) && | |
| 285 ReadParam(m, iter, &r->clip_rect) && | |
| 286 ReadParam(m, iter, &r->windowless_buffer) && | |
| 287 ReadParam(m, iter, &r->background_buffer) && | |
| 288 ReadParam(m, iter, &r->transparent) | |
| 289 #if defined(OS_MACOSX) | |
| 290 && | |
| 291 ReadParam(m, iter, &r->ack_key) | |
| 292 #endif | |
| 293 ; | |
| 294 } | |
| 295 | |
| 296 void ParamTraits<PluginMsg_UpdateGeometry_Param>::Log(const param_type& p, | |
| 297 std::string* l) { | |
| 298 l->append("("); | |
| 299 LogParam(p.window_rect, l); | |
| 300 l->append(", "); | |
| 301 LogParam(p.clip_rect, l); | |
| 302 l->append(", "); | |
| 303 LogParam(p.windowless_buffer, l); | |
| 304 l->append(", "); | |
| 305 LogParam(p.background_buffer, l); | |
| 306 l->append(", "); | |
| 307 LogParam(p.transparent, l); | |
| 308 #if defined(OS_MACOSX) | |
| 309 l->append(", "); | |
| 310 LogParam(p.ack_key, l); | |
| 311 #endif | |
| 312 l->append(")"); | |
| 313 } | |
| 314 | |
| 315 } // namespace IPC | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 6682033:
Move plugin messages to content. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/