| 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/render_messages_params.h" |
| 6 |
| 7 #include "chrome/common/navigation_gesture.h" |
| 8 #include "chrome/common/common_param_traits.h" |
| 9 #include "chrome/common/indexed_db_param_traits.h" |
| 10 #include "chrome/common/render_messages.h" |
| 11 #include "net/base/upload_data.h" |
| 12 |
| 13 bool ViewMsg_Print_Params::Equals(const ViewMsg_Print_Params& rhs) const { |
| 14 return page_size == rhs.page_size && |
| 15 printable_size == rhs.printable_size && |
| 16 margin_top == rhs.margin_top && |
| 17 margin_left == rhs.margin_left && |
| 18 dpi == rhs.dpi && |
| 19 min_shrink == rhs.min_shrink && |
| 20 max_shrink == rhs.max_shrink && |
| 21 desired_dpi == rhs.desired_dpi && |
| 22 selection_only == rhs.selection_only; |
| 23 } |
| 24 |
| 25 bool ViewMsg_Print_Params::IsEmpty() const { |
| 26 return !document_cookie && !desired_dpi && !max_shrink && !min_shrink && |
| 27 !dpi && printable_size.IsEmpty() && !selection_only && |
| 28 page_size.IsEmpty() && !margin_top && !margin_left; |
| 29 } |
| 30 |
| 31 ViewMsg_ExecuteCode_Params::ViewMsg_ExecuteCode_Params() { |
| 32 } |
| 33 |
| 34 ViewMsg_ExecuteCode_Params::ViewMsg_ExecuteCode_Params( |
| 35 int request_id, |
| 36 const std::string& extension_id, |
| 37 const std::vector<URLPattern>& host_permissions, |
| 38 bool is_javascript, |
| 39 const std::string& code, |
| 40 bool all_frames) |
| 41 : request_id(request_id), extension_id(extension_id), |
| 42 host_permissions(host_permissions), is_javascript(is_javascript), |
| 43 code(code), all_frames(all_frames) { |
| 44 } |
| 45 |
| 46 namespace IPC { |
| 47 |
| 48 // Self contained templates which are only used inside serializing Params |
| 49 // structs. |
| 50 template<> |
| 51 struct ParamTraits<ViewMsg_Navigate_Params::NavigationType> { |
| 52 typedef ViewMsg_Navigate_Params::NavigationType param_type; |
| 53 static void Write(Message* m, const param_type& p) { |
| 54 m->WriteInt(p); |
| 55 } |
| 56 static bool Read(const Message* m, void** iter, param_type* p) { |
| 57 int type; |
| 58 if (!m->ReadInt(iter, &type)) |
| 59 return false; |
| 60 *p = static_cast<ViewMsg_Navigate_Params::NavigationType>(type); |
| 61 return true; |
| 62 } |
| 63 static void Log(const param_type& p, std::string* l) { |
| 64 std::string event; |
| 65 switch (p) { |
| 66 case ViewMsg_Navigate_Params::RELOAD: |
| 67 event = "NavigationType_RELOAD"; |
| 68 break; |
| 69 |
| 70 case ViewMsg_Navigate_Params::RELOAD_IGNORING_CACHE: |
| 71 event = "NavigationType_RELOAD_IGNORING_CACHE"; |
| 72 break; |
| 73 |
| 74 case ViewMsg_Navigate_Params::RESTORE: |
| 75 event = "NavigationType_RESTORE"; |
| 76 break; |
| 77 |
| 78 case ViewMsg_Navigate_Params::NORMAL: |
| 79 event = "NavigationType_NORMA"; |
| 80 break; |
| 81 |
| 82 default: |
| 83 event = "NavigationType_UNKNOWN"; |
| 84 break; |
| 85 } |
| 86 LogParam(event, l); |
| 87 } |
| 88 }; |
| 89 |
| 90 template <> |
| 91 struct ParamTraits<ResourceType::Type> { |
| 92 typedef ResourceType::Type param_type; |
| 93 static void Write(Message* m, const param_type& p) { |
| 94 m->WriteInt(p); |
| 95 } |
| 96 static bool Read(const Message* m, void** iter, param_type* p) { |
| 97 int type; |
| 98 if (!m->ReadInt(iter, &type) || !ResourceType::ValidType(type)) |
| 99 return false; |
| 100 *p = ResourceType::FromInt(type); |
| 101 return true; |
| 102 } |
| 103 static void Log(const param_type& p, std::string* l) { |
| 104 std::string type; |
| 105 switch (p) { |
| 106 case ResourceType::MAIN_FRAME: |
| 107 type = "MAIN_FRAME"; |
| 108 break; |
| 109 case ResourceType::SUB_FRAME: |
| 110 type = "SUB_FRAME"; |
| 111 break; |
| 112 case ResourceType::SUB_RESOURCE: |
| 113 type = "SUB_RESOURCE"; |
| 114 break; |
| 115 case ResourceType::OBJECT: |
| 116 type = "OBJECT"; |
| 117 break; |
| 118 case ResourceType::MEDIA: |
| 119 type = "MEDIA"; |
| 120 break; |
| 121 default: |
| 122 type = "UNKNOWN"; |
| 123 break; |
| 124 } |
| 125 |
| 126 LogParam(type, l); |
| 127 } |
| 128 }; |
| 129 |
| 130 template<> |
| 131 struct ParamTraits<NavigationGesture> { |
| 132 typedef NavigationGesture param_type; |
| 133 static void Write(Message* m, const param_type& p) { |
| 134 m->WriteInt(p); |
| 135 } |
| 136 static bool Read(const Message* m, void** iter, param_type* p) { |
| 137 int type; |
| 138 if (!m->ReadInt(iter, &type)) |
| 139 return false; |
| 140 *p = static_cast<NavigationGesture>(type); |
| 141 return true; |
| 142 } |
| 143 static void Log(const param_type& p, std::string* l) { |
| 144 std::string event; |
| 145 switch (p) { |
| 146 case NavigationGestureUser: |
| 147 event = "GESTURE_USER"; |
| 148 break; |
| 149 case NavigationGestureAuto: |
| 150 event = "GESTURE_AUTO"; |
| 151 break; |
| 152 default: |
| 153 event = "GESTURE_UNKNOWN"; |
| 154 break; |
| 155 } |
| 156 LogParam(event, l); |
| 157 } |
| 158 }; |
| 159 |
| 160 // Traits for AudioManager::Format. |
| 161 template <> |
| 162 struct ParamTraits<AudioManager::Format> { |
| 163 typedef AudioManager::Format param_type; |
| 164 static void Write(Message* m, const param_type& p) { |
| 165 m->WriteInt(p); |
| 166 } |
| 167 static bool Read(const Message* m, void** iter, param_type* p) { |
| 168 int type; |
| 169 if (!m->ReadInt(iter, &type)) |
| 170 return false; |
| 171 *p = static_cast<AudioManager::Format>(type); |
| 172 return true; |
| 173 } |
| 174 static void Log(const param_type& p, std::string* l) { |
| 175 std::string format; |
| 176 switch (p) { |
| 177 case AudioManager::AUDIO_PCM_LINEAR: |
| 178 format = "AUDIO_PCM_LINEAR"; |
| 179 break; |
| 180 case AudioManager::AUDIO_PCM_LOW_LATENCY: |
| 181 format = "AUDIO_PCM_LOW_LATENCY"; |
| 182 break; |
| 183 case AudioManager::AUDIO_MOCK: |
| 184 format = "AUDIO_MOCK"; |
| 185 break; |
| 186 default: |
| 187 format = "AUDIO_LAST_FORMAT"; |
| 188 break; |
| 189 } |
| 190 LogParam(format, l); |
| 191 } |
| 192 }; |
| 193 |
| 194 template <> |
| 195 struct ParamTraits<WindowContainerType> { |
| 196 typedef WindowContainerType param_type; |
| 197 static void Write(Message* m, const param_type& p) { |
| 198 int val = static_cast<int>(p); |
| 199 WriteParam(m, val); |
| 200 } |
| 201 static bool Read(const Message* m, void** iter, param_type* p) { |
| 202 int val = 0; |
| 203 if (!ReadParam(m, iter, &val) || |
| 204 val < WINDOW_CONTAINER_TYPE_NORMAL || |
| 205 val >= WINDOW_CONTAINER_TYPE_MAX_VALUE) |
| 206 return false; |
| 207 *p = static_cast<param_type>(val); |
| 208 return true; |
| 209 } |
| 210 static void Log(const param_type& p, std::string* l) { |
| 211 ParamTraits<int>::Log(static_cast<int>(p), l); |
| 212 } |
| 213 }; |
| 214 |
| 215 void ParamTraits<ViewMsg_Navigate_Params>::Write(Message* m, |
| 216 const param_type& p) { |
| 217 WriteParam(m, p.page_id); |
| 218 WriteParam(m, p.pending_history_list_offset); |
| 219 WriteParam(m, p.current_history_list_offset); |
| 220 WriteParam(m, p.current_history_list_length); |
| 221 WriteParam(m, p.url); |
| 222 WriteParam(m, p.referrer); |
| 223 WriteParam(m, p.transition); |
| 224 WriteParam(m, p.state); |
| 225 WriteParam(m, p.navigation_type); |
| 226 WriteParam(m, p.request_time); |
| 227 } |
| 228 |
| 229 bool ParamTraits<ViewMsg_Navigate_Params>::Read(const Message* m, void** iter, |
| 230 param_type* p) { |
| 231 return |
| 232 ReadParam(m, iter, &p->page_id) && |
| 233 ReadParam(m, iter, &p->pending_history_list_offset) && |
| 234 ReadParam(m, iter, &p->current_history_list_offset) && |
| 235 ReadParam(m, iter, &p->current_history_list_length) && |
| 236 ReadParam(m, iter, &p->url) && |
| 237 ReadParam(m, iter, &p->referrer) && |
| 238 ReadParam(m, iter, &p->transition) && |
| 239 ReadParam(m, iter, &p->state) && |
| 240 ReadParam(m, iter, &p->navigation_type) && |
| 241 ReadParam(m, iter, &p->request_time); |
| 242 } |
| 243 |
| 244 void ParamTraits<ViewMsg_Navigate_Params>::Log(const param_type& p, |
| 245 std::string* l) { |
| 246 l->append("("); |
| 247 LogParam(p.page_id, l); |
| 248 l->append(", "); |
| 249 LogParam(p.url, l); |
| 250 l->append(", "); |
| 251 LogParam(p.transition, l); |
| 252 l->append(", "); |
| 253 LogParam(p.state, l); |
| 254 l->append(", "); |
| 255 LogParam(p.navigation_type, l); |
| 256 l->append(", "); |
| 257 LogParam(p.request_time, l); |
| 258 l->append(")"); |
| 259 } |
| 260 |
| 261 void ParamTraits<ViewMsg_AudioStreamState_Params>::Write(Message* m, |
| 262 const param_type& p) { |
| 263 m->WriteInt(p.state); |
| 264 } |
| 265 |
| 266 bool ParamTraits<ViewMsg_AudioStreamState_Params>::Read(const Message* m, |
| 267 void** iter, |
| 268 param_type* p) { |
| 269 int type; |
| 270 if (!m->ReadInt(iter, &type)) |
| 271 return false; |
| 272 p->state = static_cast<ViewMsg_AudioStreamState_Params::State>(type); |
| 273 return true; |
| 274 } |
| 275 |
| 276 void ParamTraits<ViewMsg_AudioStreamState_Params>::Log(const param_type& p, |
| 277 std::string* l) { |
| 278 std::string state; |
| 279 switch (p.state) { |
| 280 case ViewMsg_AudioStreamState_Params::kPlaying: |
| 281 state = "ViewMsg_AudioStreamState_Params::kPlaying"; |
| 282 break; |
| 283 case ViewMsg_AudioStreamState_Params::kPaused: |
| 284 state = "ViewMsg_AudioStreamState_Params::kPaused"; |
| 285 break; |
| 286 case ViewMsg_AudioStreamState_Params::kError: |
| 287 state = "ViewMsg_AudioStreamState_Params::kError"; |
| 288 break; |
| 289 default: |
| 290 state = "UNKNOWN"; |
| 291 break; |
| 292 } |
| 293 LogParam(state, l); |
| 294 } |
| 295 |
| 296 void ParamTraits<ViewMsg_StopFinding_Params>::Write(Message* m, |
| 297 const param_type& p) { |
| 298 m->WriteInt(p.action); |
| 299 } |
| 300 |
| 301 bool ParamTraits<ViewMsg_StopFinding_Params>::Read(const Message* m, |
| 302 void** iter, |
| 303 param_type* p) { |
| 304 int type; |
| 305 if (!m->ReadInt(iter, &type)) |
| 306 return false; |
| 307 p->action = static_cast<ViewMsg_StopFinding_Params::Action>(type); |
| 308 return true; |
| 309 } |
| 310 |
| 311 void ParamTraits<ViewMsg_StopFinding_Params>::Log(const param_type& p, |
| 312 std::string* l) { |
| 313 std::string action; |
| 314 switch (p.action) { |
| 315 case ViewMsg_StopFinding_Params::kClearSelection: |
| 316 action = "ViewMsg_StopFinding_Params::kClearSelection"; |
| 317 break; |
| 318 case ViewMsg_StopFinding_Params::kKeepSelection: |
| 319 action = "ViewMsg_StopFinding_Params::kKeepSelection"; |
| 320 break; |
| 321 case ViewMsg_StopFinding_Params::kActivateSelection: |
| 322 action = "ViewMsg_StopFinding_Params::kActivateSelection"; |
| 323 break; |
| 324 default: |
| 325 action = "UNKNOWN"; |
| 326 break; |
| 327 } |
| 328 LogParam(action, l); |
| 329 } |
| 330 |
| 331 void ParamTraits<ViewHostMsg_GetSearchProviderInstallState_Params>::Write( |
| 332 Message* m, const param_type& p) { |
| 333 m->WriteInt(p.state); |
| 334 } |
| 335 |
| 336 bool ParamTraits<ViewHostMsg_GetSearchProviderInstallState_Params>::Read( |
| 337 const Message* m, void** iter, param_type* p) { |
| 338 int type; |
| 339 if (!m->ReadInt(iter, &type)) |
| 340 return false; |
| 341 p->state = static_cast<param_type::State>(type); |
| 342 return true; |
| 343 } |
| 344 |
| 345 void ParamTraits<ViewHostMsg_GetSearchProviderInstallState_Params>::Log( |
| 346 const param_type& p, std::string* l) { |
| 347 std::string state; |
| 348 switch (p.state) { |
| 349 case ViewHostMsg_GetSearchProviderInstallState_Params::DENIED: |
| 350 state = "ViewHostMsg_GetSearchProviderInstallState_Params::DENIED"; |
| 351 break; |
| 352 case ViewHostMsg_GetSearchProviderInstallState_Params::NOT_INSTALLED: |
| 353 state = |
| 354 "ViewHostMsg_GetSearchProviderInstallState_Params::NOT_INSTALLED"; |
| 355 break; |
| 356 case ViewHostMsg_GetSearchProviderInstallState_Params:: |
| 357 INSTALLED_BUT_NOT_DEFAULT: |
| 358 state = "ViewHostMsg_GetSearchProviderInstallState_Params::" |
| 359 "INSTALLED_BUT_NOT_DEFAULT"; |
| 360 break; |
| 361 case ViewHostMsg_GetSearchProviderInstallState_Params:: |
| 362 INSTALLED_AS_DEFAULT: |
| 363 state = "ViewHostMsg_GetSearchProviderInstallState_Params::" |
| 364 "INSTALLED_AS_DEFAULT"; |
| 365 break; |
| 366 default: |
| 367 state = "UNKNOWN"; |
| 368 break; |
| 369 } |
| 370 LogParam(state, l); |
| 371 } |
| 372 |
| 373 void ParamTraits<ViewHostMsg_FrameNavigate_Params>::Write(Message* m, |
| 374 const param_type& p) { |
| 375 WriteParam(m, p.page_id); |
| 376 WriteParam(m, p.url); |
| 377 WriteParam(m, p.referrer); |
| 378 WriteParam(m, p.transition); |
| 379 WriteParam(m, p.redirects); |
| 380 WriteParam(m, p.should_update_history); |
| 381 WriteParam(m, p.searchable_form_url); |
| 382 WriteParam(m, p.searchable_form_encoding); |
| 383 WriteParam(m, p.password_form); |
| 384 WriteParam(m, p.security_info); |
| 385 WriteParam(m, p.gesture); |
| 386 WriteParam(m, p.contents_mime_type); |
| 387 WriteParam(m, p.is_post); |
| 388 WriteParam(m, p.is_content_filtered); |
| 389 WriteParam(m, p.http_status_code); |
| 390 } |
| 391 |
| 392 bool ParamTraits<ViewHostMsg_FrameNavigate_Params>::Read(const Message* m, |
| 393 void** iter, |
| 394 param_type* p) { |
| 395 return |
| 396 ReadParam(m, iter, &p->page_id) && |
| 397 ReadParam(m, iter, &p->url) && |
| 398 ReadParam(m, iter, &p->referrer) && |
| 399 ReadParam(m, iter, &p->transition) && |
| 400 ReadParam(m, iter, &p->redirects) && |
| 401 ReadParam(m, iter, &p->should_update_history) && |
| 402 ReadParam(m, iter, &p->searchable_form_url) && |
| 403 ReadParam(m, iter, &p->searchable_form_encoding) && |
| 404 ReadParam(m, iter, &p->password_form) && |
| 405 ReadParam(m, iter, &p->security_info) && |
| 406 ReadParam(m, iter, &p->gesture) && |
| 407 ReadParam(m, iter, &p->contents_mime_type) && |
| 408 ReadParam(m, iter, &p->is_post) && |
| 409 ReadParam(m, iter, &p->is_content_filtered) && |
| 410 ReadParam(m, iter, &p->http_status_code); |
| 411 } |
| 412 |
| 413 void ParamTraits<ViewHostMsg_FrameNavigate_Params>::Log(const param_type& p, |
| 414 std::string* l) { |
| 415 l->append("("); |
| 416 LogParam(p.page_id, l); |
| 417 l->append(", "); |
| 418 LogParam(p.url, l); |
| 419 l->append(", "); |
| 420 LogParam(p.referrer, l); |
| 421 l->append(", "); |
| 422 LogParam(p.transition, l); |
| 423 l->append(", "); |
| 424 LogParam(p.redirects, l); |
| 425 l->append(", "); |
| 426 LogParam(p.should_update_history, l); |
| 427 l->append(", "); |
| 428 LogParam(p.searchable_form_url, l); |
| 429 l->append(", "); |
| 430 LogParam(p.searchable_form_encoding, l); |
| 431 l->append(", "); |
| 432 LogParam(p.password_form, l); |
| 433 l->append(", "); |
| 434 LogParam(p.security_info, l); |
| 435 l->append(", "); |
| 436 LogParam(p.gesture, l); |
| 437 l->append(", "); |
| 438 LogParam(p.contents_mime_type, l); |
| 439 l->append(", "); |
| 440 LogParam(p.is_post, l); |
| 441 l->append(", "); |
| 442 LogParam(p.is_content_filtered, l); |
| 443 l->append(", "); |
| 444 LogParam(p.http_status_code, l); |
| 445 l->append(")"); |
| 446 } |
| 447 |
| 448 void ParamTraits<ViewHostMsg_UpdateRect_Params>::Write( |
| 449 Message* m, const param_type& p) { |
| 450 WriteParam(m, p.bitmap); |
| 451 WriteParam(m, p.bitmap_rect); |
| 452 WriteParam(m, p.dx); |
| 453 WriteParam(m, p.dy); |
| 454 WriteParam(m, p.scroll_rect); |
| 455 WriteParam(m, p.copy_rects); |
| 456 WriteParam(m, p.view_size); |
| 457 WriteParam(m, p.plugin_window_moves); |
| 458 WriteParam(m, p.flags); |
| 459 } |
| 460 |
| 461 bool ParamTraits<ViewHostMsg_UpdateRect_Params>::Read( |
| 462 const Message* m, void** iter, param_type* p) { |
| 463 return |
| 464 ReadParam(m, iter, &p->bitmap) && |
| 465 ReadParam(m, iter, &p->bitmap_rect) && |
| 466 ReadParam(m, iter, &p->dx) && |
| 467 ReadParam(m, iter, &p->dy) && |
| 468 ReadParam(m, iter, &p->scroll_rect) && |
| 469 ReadParam(m, iter, &p->copy_rects) && |
| 470 ReadParam(m, iter, &p->view_size) && |
| 471 ReadParam(m, iter, &p->plugin_window_moves) && |
| 472 ReadParam(m, iter, &p->flags); |
| 473 } |
| 474 |
| 475 void ParamTraits<ViewHostMsg_UpdateRect_Params>::Log(const param_type& p, |
| 476 std::string* l) { |
| 477 l->append("("); |
| 478 LogParam(p.bitmap, l); |
| 479 l->append(", "); |
| 480 LogParam(p.bitmap_rect, l); |
| 481 l->append(", "); |
| 482 LogParam(p.dx, l); |
| 483 l->append(", "); |
| 484 LogParam(p.dy, l); |
| 485 l->append(", "); |
| 486 LogParam(p.scroll_rect, l); |
| 487 l->append(", "); |
| 488 LogParam(p.copy_rects, l); |
| 489 l->append(", "); |
| 490 LogParam(p.view_size, l); |
| 491 l->append(", "); |
| 492 LogParam(p.plugin_window_moves, l); |
| 493 l->append(", "); |
| 494 LogParam(p.flags, l); |
| 495 l->append(")"); |
| 496 } |
| 497 |
| 498 void ParamTraits<ViewMsg_ClosePage_Params>::Write(Message* m, |
| 499 const param_type& p) { |
| 500 WriteParam(m, p.closing_process_id); |
| 501 WriteParam(m, p.closing_route_id); |
| 502 WriteParam(m, p.for_cross_site_transition); |
| 503 WriteParam(m, p.new_render_process_host_id); |
| 504 WriteParam(m, p.new_request_id); |
| 505 } |
| 506 |
| 507 bool ParamTraits<ViewMsg_ClosePage_Params>::Read(const Message* m, |
| 508 void** iter, |
| 509 param_type* r) { |
| 510 return ReadParam(m, iter, &r->closing_process_id) && |
| 511 ReadParam(m, iter, &r->closing_route_id) && |
| 512 ReadParam(m, iter, &r->for_cross_site_transition) && |
| 513 ReadParam(m, iter, &r->new_render_process_host_id) && |
| 514 ReadParam(m, iter, &r->new_request_id); |
| 515 } |
| 516 |
| 517 void ParamTraits<ViewMsg_ClosePage_Params>::Log(const param_type& p, |
| 518 std::string* l) { |
| 519 l->append("("); |
| 520 LogParam(p.closing_process_id, l); |
| 521 l->append(", "); |
| 522 LogParam(p.closing_route_id, l); |
| 523 l->append(", "); |
| 524 LogParam(p.for_cross_site_transition, l); |
| 525 l->append(", "); |
| 526 LogParam(p.new_render_process_host_id, l); |
| 527 l->append(", "); |
| 528 LogParam(p.new_request_id, l); |
| 529 l->append(")"); |
| 530 } |
| 531 |
| 532 void ParamTraits<ViewHostMsg_Resource_Request>::Write(Message* m, |
| 533 const param_type& p) { |
| 534 WriteParam(m, p.method); |
| 535 WriteParam(m, p.url); |
| 536 WriteParam(m, p.first_party_for_cookies); |
| 537 WriteParam(m, p.referrer); |
| 538 WriteParam(m, p.frame_origin); |
| 539 WriteParam(m, p.main_frame_origin); |
| 540 WriteParam(m, p.headers); |
| 541 WriteParam(m, p.load_flags); |
| 542 WriteParam(m, p.origin_child_id); |
| 543 WriteParam(m, p.resource_type); |
| 544 WriteParam(m, p.request_context); |
| 545 WriteParam(m, p.appcache_host_id); |
| 546 WriteParam(m, p.upload_data); |
| 547 WriteParam(m, p.download_to_file); |
| 548 WriteParam(m, p.host_renderer_id); |
| 549 WriteParam(m, p.host_render_view_id); |
| 550 } |
| 551 |
| 552 bool ParamTraits<ViewHostMsg_Resource_Request>::Read(const Message* m, |
| 553 void** iter, |
| 554 param_type* r) { |
| 555 return |
| 556 ReadParam(m, iter, &r->method) && |
| 557 ReadParam(m, iter, &r->url) && |
| 558 ReadParam(m, iter, &r->first_party_for_cookies) && |
| 559 ReadParam(m, iter, &r->referrer) && |
| 560 ReadParam(m, iter, &r->frame_origin) && |
| 561 ReadParam(m, iter, &r->main_frame_origin) && |
| 562 ReadParam(m, iter, &r->headers) && |
| 563 ReadParam(m, iter, &r->load_flags) && |
| 564 ReadParam(m, iter, &r->origin_child_id) && |
| 565 ReadParam(m, iter, &r->resource_type) && |
| 566 ReadParam(m, iter, &r->request_context) && |
| 567 ReadParam(m, iter, &r->appcache_host_id) && |
| 568 ReadParam(m, iter, &r->upload_data) && |
| 569 ReadParam(m, iter, &r->download_to_file) && |
| 570 ReadParam(m, iter, &r->host_renderer_id) && |
| 571 ReadParam(m, iter, &r->host_render_view_id); |
| 572 } |
| 573 |
| 574 void ParamTraits<ViewHostMsg_Resource_Request>::Log(const param_type& p, |
| 575 std::string* l) { |
| 576 l->append("("); |
| 577 LogParam(p.method, l); |
| 578 l->append(", "); |
| 579 LogParam(p.url, l); |
| 580 l->append(", "); |
| 581 LogParam(p.referrer, l); |
| 582 l->append(", "); |
| 583 LogParam(p.frame_origin, l); |
| 584 l->append(", "); |
| 585 LogParam(p.main_frame_origin, l); |
| 586 l->append(", "); |
| 587 LogParam(p.load_flags, l); |
| 588 l->append(", "); |
| 589 LogParam(p.origin_child_id, l); |
| 590 l->append(", "); |
| 591 LogParam(p.resource_type, l); |
| 592 l->append(", "); |
| 593 LogParam(p.request_context, l); |
| 594 l->append(", "); |
| 595 LogParam(p.appcache_host_id, l); |
| 596 l->append(", "); |
| 597 LogParam(p.download_to_file, l); |
| 598 l->append(", "); |
| 599 LogParam(p.host_renderer_id, l); |
| 600 l->append(", "); |
| 601 LogParam(p.host_render_view_id, l); |
| 602 l->append(")"); |
| 603 } |
| 604 |
| 605 void ParamTraits<ViewMsg_Print_Params>::Write(Message* m, const param_type& p) { |
| 606 WriteParam(m, p.page_size); |
| 607 WriteParam(m, p.printable_size); |
| 608 WriteParam(m, p.margin_top); |
| 609 WriteParam(m, p.margin_left); |
| 610 WriteParam(m, p.dpi); |
| 611 WriteParam(m, p.min_shrink); |
| 612 WriteParam(m, p.max_shrink); |
| 613 WriteParam(m, p.desired_dpi); |
| 614 WriteParam(m, p.document_cookie); |
| 615 WriteParam(m, p.selection_only); |
| 616 } |
| 617 |
| 618 bool ParamTraits<ViewMsg_Print_Params>::Read(const Message* m, |
| 619 void** iter, |
| 620 param_type* p) { |
| 621 return ReadParam(m, iter, &p->page_size) && |
| 622 ReadParam(m, iter, &p->printable_size) && |
| 623 ReadParam(m, iter, &p->margin_top) && |
| 624 ReadParam(m, iter, &p->margin_left) && |
| 625 ReadParam(m, iter, &p->dpi) && |
| 626 ReadParam(m, iter, &p->min_shrink) && |
| 627 ReadParam(m, iter, &p->max_shrink) && |
| 628 ReadParam(m, iter, &p->desired_dpi) && |
| 629 ReadParam(m, iter, &p->document_cookie) && |
| 630 ReadParam(m, iter, &p->selection_only); |
| 631 } |
| 632 |
| 633 void ParamTraits<ViewMsg_Print_Params>::Log(const param_type& p, |
| 634 std::string* l) { |
| 635 l->append("<ViewMsg_Print_Params>"); |
| 636 } |
| 637 |
| 638 void ParamTraits<ViewMsg_PrintPage_Params>::Write(Message* m, |
| 639 const param_type& p) { |
| 640 WriteParam(m, p.params); |
| 641 WriteParam(m, p.page_number); |
| 642 } |
| 643 |
| 644 bool ParamTraits<ViewMsg_PrintPage_Params>::Read(const Message* m, |
| 645 void** iter, |
| 646 param_type* p) { |
| 647 return ReadParam(m, iter, &p->params) && |
| 648 ReadParam(m, iter, &p->page_number); |
| 649 } |
| 650 |
| 651 void ParamTraits<ViewMsg_PrintPage_Params>::Log(const param_type& p, |
| 652 std::string* l) { |
| 653 l->append("<ViewMsg_PrintPage_Params>"); |
| 654 } |
| 655 |
| 656 void ParamTraits<ViewMsg_PrintPages_Params>::Write(Message* m, |
| 657 const param_type& p) { |
| 658 WriteParam(m, p.params); |
| 659 WriteParam(m, p.pages); |
| 660 } |
| 661 |
| 662 bool ParamTraits<ViewMsg_PrintPages_Params>::Read(const Message* m, |
| 663 void** iter, |
| 664 param_type* p) { |
| 665 return ReadParam(m, iter, &p->params) && |
| 666 ReadParam(m, iter, &p->pages); |
| 667 } |
| 668 |
| 669 void ParamTraits<ViewMsg_PrintPages_Params>::Log(const param_type& p, |
| 670 std::string* l) { |
| 671 l->append("<ViewMsg_PrintPages_Params>"); |
| 672 } |
| 673 |
| 674 void ParamTraits<ViewHostMsg_DidPrintPage_Params>::Write(Message* m, |
| 675 const param_type& p) { |
| 676 WriteParam(m, p.metafile_data_handle); |
| 677 WriteParam(m, p.data_size); |
| 678 WriteParam(m, p.document_cookie); |
| 679 WriteParam(m, p.page_number); |
| 680 WriteParam(m, p.actual_shrink); |
| 681 WriteParam(m, p.page_size); |
| 682 WriteParam(m, p.content_area); |
| 683 WriteParam(m, p.has_visible_overlays); |
| 684 } |
| 685 |
| 686 bool ParamTraits<ViewHostMsg_DidPrintPage_Params>::Read(const Message* m, |
| 687 void** iter, |
| 688 param_type* p) { |
| 689 return ReadParam(m, iter, &p->metafile_data_handle) && |
| 690 ReadParam(m, iter, &p->data_size) && |
| 691 ReadParam(m, iter, &p->document_cookie) && |
| 692 ReadParam(m, iter, &p->page_number) && |
| 693 ReadParam(m, iter, &p->actual_shrink) && |
| 694 ReadParam(m, iter, &p->page_size) && |
| 695 ReadParam(m, iter, &p->content_area) && |
| 696 ReadParam(m, iter, &p->has_visible_overlays); |
| 697 } |
| 698 |
| 699 void ParamTraits<ViewHostMsg_DidPrintPage_Params>::Log(const param_type& p, |
| 700 std::string* l) { |
| 701 l->append("<ViewHostMsg_DidPrintPage_Params>"); |
| 702 } |
| 703 |
| 704 void ParamTraits<ViewHostMsg_Audio_CreateStream_Params>::Write( |
| 705 Message* m, |
| 706 const param_type& p) { |
| 707 WriteParam(m, p.format); |
| 708 WriteParam(m, p.channels); |
| 709 WriteParam(m, p.sample_rate); |
| 710 WriteParam(m, p.bits_per_sample); |
| 711 WriteParam(m, p.packet_size); |
| 712 } |
| 713 |
| 714 bool ParamTraits<ViewHostMsg_Audio_CreateStream_Params>::Read(const Message* m, |
| 715 void** iter, |
| 716 param_type* p) { |
| 717 return |
| 718 ReadParam(m, iter, &p->format) && |
| 719 ReadParam(m, iter, &p->channels) && |
| 720 ReadParam(m, iter, &p->sample_rate) && |
| 721 ReadParam(m, iter, &p->bits_per_sample) && |
| 722 ReadParam(m, iter, &p->packet_size); |
| 723 } |
| 724 |
| 725 void ParamTraits<ViewHostMsg_Audio_CreateStream_Params>::Log( |
| 726 const param_type& p, |
| 727 std::string* l) { |
| 728 l->append("<ViewHostMsg_Audio_CreateStream_Params>("); |
| 729 LogParam(p.format, l); |
| 730 l->append(", "); |
| 731 LogParam(p.channels, l); |
| 732 l->append(", "); |
| 733 LogParam(p.sample_rate, l); |
| 734 l->append(", "); |
| 735 LogParam(p.bits_per_sample, l); |
| 736 l->append(", "); |
| 737 LogParam(p.packet_size, l); |
| 738 l->append(")"); |
| 739 } |
| 740 |
| 741 void ParamTraits<ViewHostMsg_ShowPopup_Params>::Write(Message* m, |
| 742 const param_type& p) { |
| 743 WriteParam(m, p.bounds); |
| 744 WriteParam(m, p.item_height); |
| 745 WriteParam(m, p.item_font_size); |
| 746 WriteParam(m, p.selected_item); |
| 747 WriteParam(m, p.popup_items); |
| 748 WriteParam(m, p.right_aligned); |
| 749 } |
| 750 |
| 751 bool ParamTraits<ViewHostMsg_ShowPopup_Params>::Read(const Message* m, |
| 752 void** iter, |
| 753 param_type* p) { |
| 754 return |
| 755 ReadParam(m, iter, &p->bounds) && |
| 756 ReadParam(m, iter, &p->item_height) && |
| 757 ReadParam(m, iter, &p->item_font_size) && |
| 758 ReadParam(m, iter, &p->selected_item) && |
| 759 ReadParam(m, iter, &p->popup_items) && |
| 760 ReadParam(m, iter, &p->right_aligned); |
| 761 } |
| 762 |
| 763 void ParamTraits<ViewHostMsg_ShowPopup_Params>::Log(const param_type& p, |
| 764 std::string* l) { |
| 765 l->append("("); |
| 766 LogParam(p.bounds, l); |
| 767 l->append(", "); |
| 768 LogParam(p.item_height, l); |
| 769 l->append(", "); |
| 770 LogParam(p.item_font_size, l); |
| 771 l->append(", "); |
| 772 LogParam(p.selected_item, l); |
| 773 l->append(", "); |
| 774 LogParam(p.popup_items, l); |
| 775 l->append(", "); |
| 776 LogParam(p.right_aligned, l); |
| 777 l->append(")"); |
| 778 } |
| 779 |
| 780 void ParamTraits<ViewHostMsg_ScriptedPrint_Params>::Write(Message* m, |
| 781 const param_type& p) { |
| 782 WriteParam(m, p.routing_id); |
| 783 WriteParam(m, p.host_window_id); |
| 784 WriteParam(m, p.cookie); |
| 785 WriteParam(m, p.expected_pages_count); |
| 786 WriteParam(m, p.has_selection); |
| 787 WriteParam(m, p.use_overlays); |
| 788 } |
| 789 |
| 790 bool ParamTraits<ViewHostMsg_ScriptedPrint_Params>::Read(const Message* m, |
| 791 void** iter, |
| 792 param_type* p) { |
| 793 return |
| 794 ReadParam(m, iter, &p->routing_id) && |
| 795 ReadParam(m, iter, &p->host_window_id) && |
| 796 ReadParam(m, iter, &p->cookie) && |
| 797 ReadParam(m, iter, &p->expected_pages_count) && |
| 798 ReadParam(m, iter, &p->has_selection) && |
| 799 ReadParam(m, iter, &p->use_overlays); |
| 800 } |
| 801 |
| 802 void ParamTraits<ViewHostMsg_ScriptedPrint_Params>::Log(const param_type& p, |
| 803 std::string* l) { |
| 804 l->append("("); |
| 805 LogParam(p.routing_id, l); |
| 806 l->append(", "); |
| 807 LogParam(p.host_window_id, l); |
| 808 l->append(", "); |
| 809 LogParam(p.cookie, l); |
| 810 l->append(", "); |
| 811 LogParam(p.expected_pages_count, l); |
| 812 l->append(", "); |
| 813 LogParam(p.has_selection, l); |
| 814 l->append(","); |
| 815 LogParam(p.use_overlays, l); |
| 816 l->append(")"); |
| 817 } |
| 818 |
| 819 void ParamTraits<ViewMsg_DOMStorageEvent_Params>::Write(Message* m, |
| 820 const param_type& p) { |
| 821 WriteParam(m, p.key_); |
| 822 WriteParam(m, p.old_value_); |
| 823 WriteParam(m, p.new_value_); |
| 824 WriteParam(m, p.origin_); |
| 825 WriteParam(m, p.url_); |
| 826 WriteParam(m, p.storage_type_); |
| 827 } |
| 828 |
| 829 bool ParamTraits<ViewMsg_DOMStorageEvent_Params>::Read(const Message* m, |
| 830 void** iter, |
| 831 param_type* p) { |
| 832 return |
| 833 ReadParam(m, iter, &p->key_) && |
| 834 ReadParam(m, iter, &p->old_value_) && |
| 835 ReadParam(m, iter, &p->new_value_) && |
| 836 ReadParam(m, iter, &p->origin_) && |
| 837 ReadParam(m, iter, &p->url_) && |
| 838 ReadParam(m, iter, &p->storage_type_); |
| 839 } |
| 840 |
| 841 void ParamTraits<ViewMsg_DOMStorageEvent_Params>::Log(const param_type& p, |
| 842 std::string* l) { |
| 843 l->append("("); |
| 844 LogParam(p.key_, l); |
| 845 l->append(", "); |
| 846 LogParam(p.old_value_, l); |
| 847 l->append(", "); |
| 848 LogParam(p.new_value_, l); |
| 849 l->append(", "); |
| 850 LogParam(p.origin_, l); |
| 851 l->append(", "); |
| 852 LogParam(p.url_, l); |
| 853 l->append(", "); |
| 854 LogParam(p.storage_type_, l); |
| 855 l->append(")"); |
| 856 } |
| 857 |
| 858 void ParamTraits<ViewHostMsg_IDBFactoryOpen_Params>::Write( |
| 859 Message* m, |
| 860 const param_type& p) { |
| 861 WriteParam(m, p.routing_id_); |
| 862 WriteParam(m, p.response_id_); |
| 863 WriteParam(m, p.origin_); |
| 864 WriteParam(m, p.name_); |
| 865 WriteParam(m, p.description_); |
| 866 } |
| 867 |
| 868 bool ParamTraits<ViewHostMsg_IDBFactoryOpen_Params>::Read(const Message* m, |
| 869 void** iter, |
| 870 param_type* p) { |
| 871 return |
| 872 ReadParam(m, iter, &p->routing_id_) && |
| 873 ReadParam(m, iter, &p->response_id_) && |
| 874 ReadParam(m, iter, &p->origin_) && |
| 875 ReadParam(m, iter, &p->name_) && |
| 876 ReadParam(m, iter, &p->description_); |
| 877 } |
| 878 |
| 879 void ParamTraits<ViewHostMsg_IDBFactoryOpen_Params>::Log(const param_type& p, |
| 880 std::string* l) { |
| 881 l->append("("); |
| 882 LogParam(p.routing_id_, l); |
| 883 l->append(", "); |
| 884 LogParam(p.response_id_, l); |
| 885 l->append(", "); |
| 886 LogParam(p.origin_, l); |
| 887 l->append(", "); |
| 888 LogParam(p.name_, l); |
| 889 l->append(", "); |
| 890 LogParam(p.description_, l); |
| 891 l->append(")"); |
| 892 } |
| 893 |
| 894 void ParamTraits<ViewHostMsg_IDBDatabaseCreateObjectStore_Params>::Write( |
| 895 Message* m, |
| 896 const param_type& p) { |
| 897 WriteParam(m, p.response_id_); |
| 898 WriteParam(m, p.name_); |
| 899 WriteParam(m, p.key_path_); |
| 900 WriteParam(m, p.auto_increment_); |
| 901 WriteParam(m, p.idb_database_id_); |
| 902 } |
| 903 |
| 904 bool ParamTraits<ViewHostMsg_IDBDatabaseCreateObjectStore_Params>::Read( |
| 905 const Message* m, |
| 906 void** iter, |
| 907 param_type* p) { |
| 908 return |
| 909 ReadParam(m, iter, &p->response_id_) && |
| 910 ReadParam(m, iter, &p->name_) && |
| 911 ReadParam(m, iter, &p->key_path_) && |
| 912 ReadParam(m, iter, &p->auto_increment_) && |
| 913 ReadParam(m, iter, &p->idb_database_id_); |
| 914 } |
| 915 |
| 916 void ParamTraits<ViewHostMsg_IDBDatabaseCreateObjectStore_Params>::Log( |
| 917 const param_type& p, |
| 918 std::string* l) { |
| 919 l->append("("); |
| 920 LogParam(p.response_id_, l); |
| 921 l->append(", "); |
| 922 LogParam(p.name_, l); |
| 923 l->append(", "); |
| 924 LogParam(p.key_path_, l); |
| 925 l->append(", "); |
| 926 LogParam(p.auto_increment_, l); |
| 927 l->append(", "); |
| 928 LogParam(p.idb_database_id_, l); |
| 929 l->append(")"); |
| 930 } |
| 931 |
| 932 void ParamTraits<ViewHostMsg_IDBObjectStoreCreateIndex_Params>::Write( |
| 933 Message* m, |
| 934 const param_type& p) { |
| 935 WriteParam(m, p.response_id_); |
| 936 WriteParam(m, p.name_); |
| 937 WriteParam(m, p.key_path_); |
| 938 WriteParam(m, p.unique_); |
| 939 WriteParam(m, p.idb_object_store_id_); |
| 940 } |
| 941 |
| 942 bool ParamTraits<ViewHostMsg_IDBObjectStoreCreateIndex_Params>::Read( |
| 943 const Message* m, |
| 944 void** iter, |
| 945 param_type* p) { |
| 946 return |
| 947 ReadParam(m, iter, &p->response_id_) && |
| 948 ReadParam(m, iter, &p->name_) && |
| 949 ReadParam(m, iter, &p->key_path_) && |
| 950 ReadParam(m, iter, &p->unique_) && |
| 951 ReadParam(m, iter, &p->idb_object_store_id_); |
| 952 } |
| 953 |
| 954 void ParamTraits<ViewHostMsg_IDBObjectStoreCreateIndex_Params>::Log( |
| 955 const param_type& p, |
| 956 std::string* l) { |
| 957 l->append("("); |
| 958 LogParam(p.response_id_, l); |
| 959 l->append(", "); |
| 960 LogParam(p.name_, l); |
| 961 l->append(", "); |
| 962 LogParam(p.key_path_, l); |
| 963 l->append(", "); |
| 964 LogParam(p.unique_, l); |
| 965 l->append(", "); |
| 966 LogParam(p.idb_object_store_id_, l); |
| 967 l->append(")"); |
| 968 } |
| 969 |
| 970 void ParamTraits<ViewHostMsg_IDBObjectStoreOpenCursor_Params>::Write( |
| 971 Message* m, |
| 972 const param_type& p) { |
| 973 WriteParam(m, p.response_id_); |
| 974 WriteParam(m, p.left_key_); |
| 975 WriteParam(m, p.right_key_); |
| 976 WriteParam(m, p.flags_); |
| 977 WriteParam(m, p.direction_); |
| 978 WriteParam(m, p.idb_object_store_id_); |
| 979 } |
| 980 |
| 981 bool ParamTraits<ViewHostMsg_IDBObjectStoreOpenCursor_Params>::Read( |
| 982 const Message* m, |
| 983 void** iter, |
| 984 param_type* p) { |
| 985 return |
| 986 ReadParam(m, iter, &p->response_id_) && |
| 987 ReadParam(m, iter, &p->left_key_) && |
| 988 ReadParam(m, iter, &p->right_key_) && |
| 989 ReadParam(m, iter, &p->flags_) && |
| 990 ReadParam(m, iter, &p->direction_) && |
| 991 ReadParam(m, iter, &p->idb_object_store_id_); |
| 992 } |
| 993 |
| 994 void ParamTraits<ViewHostMsg_IDBObjectStoreOpenCursor_Params>::Log( |
| 995 const param_type& p, |
| 996 std::string* l) { |
| 997 l->append("("); |
| 998 LogParam(p.response_id_, l); |
| 999 l->append(", "); |
| 1000 LogParam(p.left_key_, l); |
| 1001 l->append(", "); |
| 1002 LogParam(p.right_key_, l); |
| 1003 l->append(", "); |
| 1004 LogParam(p.flags_, l); |
| 1005 l->append(", "); |
| 1006 LogParam(p.direction_, l); |
| 1007 l->append(", "); |
| 1008 LogParam(p.idb_object_store_id_, l); |
| 1009 l->append(")"); |
| 1010 } |
| 1011 |
| 1012 void ParamTraits<ViewMsg_ExecuteCode_Params>::Write(Message* m, |
| 1013 const param_type& p) { |
| 1014 WriteParam(m, p.request_id); |
| 1015 WriteParam(m, p.extension_id); |
| 1016 WriteParam(m, p.host_permissions); |
| 1017 WriteParam(m, p.is_javascript); |
| 1018 WriteParam(m, p.code); |
| 1019 WriteParam(m, p.all_frames); |
| 1020 } |
| 1021 |
| 1022 bool ParamTraits<ViewMsg_ExecuteCode_Params>::Read(const Message* m, |
| 1023 void** iter, |
| 1024 param_type* p) { |
| 1025 return |
| 1026 ReadParam(m, iter, &p->request_id) && |
| 1027 ReadParam(m, iter, &p->extension_id) && |
| 1028 ReadParam(m, iter, &p->host_permissions) && |
| 1029 ReadParam(m, iter, &p->is_javascript) && |
| 1030 ReadParam(m, iter, &p->code) && |
| 1031 ReadParam(m, iter, &p->all_frames); |
| 1032 } |
| 1033 |
| 1034 void ParamTraits<ViewMsg_ExecuteCode_Params>::Log(const param_type& p, |
| 1035 std::string* l) { |
| 1036 l->append("<ViewMsg_ExecuteCode_Params>"); |
| 1037 } |
| 1038 |
| 1039 void ParamTraits<ViewHostMsg_CreateWorker_Params>::Write(Message* m, |
| 1040 const param_type& p) { |
| 1041 WriteParam(m, p.url); |
| 1042 WriteParam(m, p.is_shared); |
| 1043 WriteParam(m, p.name); |
| 1044 WriteParam(m, p.document_id); |
| 1045 WriteParam(m, p.render_view_route_id); |
| 1046 WriteParam(m, p.route_id); |
| 1047 WriteParam(m, p.parent_appcache_host_id); |
| 1048 WriteParam(m, p.script_resource_appcache_id); |
| 1049 } |
| 1050 |
| 1051 bool ParamTraits<ViewHostMsg_CreateWorker_Params>::Read(const Message* m, |
| 1052 void** iter, |
| 1053 param_type* p) { |
| 1054 return |
| 1055 ReadParam(m, iter, &p->url) && |
| 1056 ReadParam(m, iter, &p->is_shared) && |
| 1057 ReadParam(m, iter, &p->name) && |
| 1058 ReadParam(m, iter, &p->document_id) && |
| 1059 ReadParam(m, iter, &p->render_view_route_id) && |
| 1060 ReadParam(m, iter, &p->route_id) && |
| 1061 ReadParam(m, iter, &p->parent_appcache_host_id) && |
| 1062 ReadParam(m, iter, &p->script_resource_appcache_id); |
| 1063 } |
| 1064 |
| 1065 void ParamTraits<ViewHostMsg_CreateWorker_Params>::Log(const param_type& p, |
| 1066 std::string* l) { |
| 1067 l->append("("); |
| 1068 LogParam(p.url, l); |
| 1069 l->append(", "); |
| 1070 LogParam(p.is_shared, l); |
| 1071 l->append(", "); |
| 1072 LogParam(p.name, l); |
| 1073 l->append(", "); |
| 1074 LogParam(p.document_id, l); |
| 1075 l->append(", "); |
| 1076 LogParam(p.render_view_route_id, l); |
| 1077 l->append(","); |
| 1078 LogParam(p.route_id, l); |
| 1079 l->append(", "); |
| 1080 LogParam(p.parent_appcache_host_id, l); |
| 1081 l->append(","); |
| 1082 LogParam(p.script_resource_appcache_id, l); |
| 1083 l->append(")"); |
| 1084 } |
| 1085 |
| 1086 void ParamTraits<ViewHostMsg_ShowNotification_Params>::Write( |
| 1087 Message* m, |
| 1088 const param_type& p) { |
| 1089 WriteParam(m, p.origin); |
| 1090 WriteParam(m, p.is_html); |
| 1091 WriteParam(m, p.contents_url); |
| 1092 WriteParam(m, p.icon_url); |
| 1093 WriteParam(m, p.title); |
| 1094 WriteParam(m, p.body); |
| 1095 WriteParam(m, p.direction); |
| 1096 WriteParam(m, p.replace_id); |
| 1097 WriteParam(m, p.notification_id); |
| 1098 } |
| 1099 |
| 1100 bool ParamTraits<ViewHostMsg_ShowNotification_Params>::Read( |
| 1101 const Message* m, |
| 1102 void** iter, |
| 1103 param_type* p) { |
| 1104 return |
| 1105 ReadParam(m, iter, &p->origin) && |
| 1106 ReadParam(m, iter, &p->is_html) && |
| 1107 ReadParam(m, iter, &p->contents_url) && |
| 1108 ReadParam(m, iter, &p->icon_url) && |
| 1109 ReadParam(m, iter, &p->title) && |
| 1110 ReadParam(m, iter, &p->body) && |
| 1111 ReadParam(m, iter, &p->direction) && |
| 1112 ReadParam(m, iter, &p->replace_id) && |
| 1113 ReadParam(m, iter, &p->notification_id); |
| 1114 } |
| 1115 |
| 1116 void ParamTraits<ViewHostMsg_ShowNotification_Params>::Log( |
| 1117 const param_type &p, |
| 1118 std::string* l) { |
| 1119 l->append("("); |
| 1120 LogParam(p.origin, l); |
| 1121 l->append(", "); |
| 1122 LogParam(p.is_html, l); |
| 1123 l->append(", "); |
| 1124 LogParam(p.contents_url, l); |
| 1125 l->append(", "); |
| 1126 LogParam(p.icon_url, l); |
| 1127 l->append(", "); |
| 1128 LogParam(p.title, l); |
| 1129 l->append(","); |
| 1130 LogParam(p.body, l); |
| 1131 l->append(","); |
| 1132 LogParam(p.direction, l); |
| 1133 l->append(","); |
| 1134 LogParam(p.replace_id, l); |
| 1135 l->append(","); |
| 1136 LogParam(p.notification_id, l); |
| 1137 l->append(")"); |
| 1138 } |
| 1139 |
| 1140 void ParamTraits<ViewMsg_New_Params>::Write(Message* m, const param_type& p) { |
| 1141 WriteParam(m, p.parent_window); |
| 1142 WriteParam(m, p.renderer_preferences); |
| 1143 WriteParam(m, p.web_preferences); |
| 1144 WriteParam(m, p.view_id); |
| 1145 WriteParam(m, p.session_storage_namespace_id); |
| 1146 WriteParam(m, p.frame_name); |
| 1147 } |
| 1148 |
| 1149 bool ParamTraits<ViewMsg_New_Params>::Read(const Message* m, |
| 1150 void** iter, |
| 1151 param_type* p) { |
| 1152 return |
| 1153 ReadParam(m, iter, &p->parent_window) && |
| 1154 ReadParam(m, iter, &p->renderer_preferences) && |
| 1155 ReadParam(m, iter, &p->web_preferences) && |
| 1156 ReadParam(m, iter, &p->view_id) && |
| 1157 ReadParam(m, iter, &p->session_storage_namespace_id) && |
| 1158 ReadParam(m, iter, &p->frame_name); |
| 1159 } |
| 1160 |
| 1161 void ParamTraits<ViewMsg_New_Params>::Log(const param_type& p, std::string* l) { |
| 1162 l->append("("); |
| 1163 LogParam(p.parent_window, l); |
| 1164 l->append(", "); |
| 1165 LogParam(p.renderer_preferences, l); |
| 1166 l->append(", "); |
| 1167 LogParam(p.web_preferences, l); |
| 1168 l->append(", "); |
| 1169 LogParam(p.view_id, l); |
| 1170 l->append(", "); |
| 1171 LogParam(p.session_storage_namespace_id, l); |
| 1172 l->append(", "); |
| 1173 LogParam(p.frame_name, l); |
| 1174 l->append(")"); |
| 1175 } |
| 1176 |
| 1177 void ParamTraits<ViewHostMsg_CreateWindow_Params>::Write(Message* m, |
| 1178 const param_type& p) { |
| 1179 WriteParam(m, p.opener_id); |
| 1180 WriteParam(m, p.user_gesture); |
| 1181 WriteParam(m, p.window_container_type); |
| 1182 WriteParam(m, p.session_storage_namespace_id); |
| 1183 WriteParam(m, p.frame_name); |
| 1184 } |
| 1185 |
| 1186 bool ParamTraits<ViewHostMsg_CreateWindow_Params>::Read(const Message* m, |
| 1187 void** iter, |
| 1188 param_type* p) { |
| 1189 return |
| 1190 ReadParam(m, iter, &p->opener_id) && |
| 1191 ReadParam(m, iter, &p->user_gesture) && |
| 1192 ReadParam(m, iter, &p->window_container_type) && |
| 1193 ReadParam(m, iter, &p->session_storage_namespace_id) && |
| 1194 ReadParam(m, iter, &p->frame_name); |
| 1195 } |
| 1196 |
| 1197 void ParamTraits<ViewHostMsg_CreateWindow_Params>::Log(const param_type& p, |
| 1198 std::string* l) { |
| 1199 l->append("("); |
| 1200 LogParam(p.opener_id, l); |
| 1201 l->append(", "); |
| 1202 LogParam(p.user_gesture, l); |
| 1203 l->append(", "); |
| 1204 LogParam(p.window_container_type, l); |
| 1205 l->append(", "); |
| 1206 LogParam(p.session_storage_namespace_id, l); |
| 1207 l->append(", "); |
| 1208 LogParam(p.frame_name, l); |
| 1209 l->append(")"); |
| 1210 } |
| 1211 |
| 1212 void ParamTraits<ViewHostMsg_RunFileChooser_Params>::Write( |
| 1213 Message* m, |
| 1214 const param_type& p) { |
| 1215 WriteParam(m, static_cast<int>(p.mode)); |
| 1216 WriteParam(m, p.title); |
| 1217 WriteParam(m, p.default_file_name); |
| 1218 } |
| 1219 |
| 1220 bool ParamTraits<ViewHostMsg_RunFileChooser_Params>::Read( |
| 1221 const Message* m, |
| 1222 void** iter, |
| 1223 param_type* p) { |
| 1224 int mode; |
| 1225 if (!ReadParam(m, iter, &mode)) |
| 1226 return false; |
| 1227 if (mode != param_type::Open && |
| 1228 mode != param_type::OpenMultiple && |
| 1229 mode != param_type::Save) |
| 1230 return false; |
| 1231 p->mode = static_cast<param_type::Mode>(mode); |
| 1232 return |
| 1233 ReadParam(m, iter, &p->title) && |
| 1234 ReadParam(m, iter, &p->default_file_name); |
| 1235 }; |
| 1236 |
| 1237 void ParamTraits<ViewHostMsg_RunFileChooser_Params>::Log( |
| 1238 const param_type& p, |
| 1239 std::string* l) { |
| 1240 switch (p.mode) { |
| 1241 case param_type::Open: |
| 1242 l->append("(Open, "); |
| 1243 break; |
| 1244 case param_type::OpenMultiple: |
| 1245 l->append("(OpenMultiple, "); |
| 1246 break; |
| 1247 case param_type::Save: |
| 1248 l->append("(Save, "); |
| 1249 break; |
| 1250 default: |
| 1251 l->append("(UNKNOWN, "); |
| 1252 } |
| 1253 LogParam(p.title, l); |
| 1254 l->append(", "); |
| 1255 LogParam(p.default_file_name, l); |
| 1256 } |
| 1257 |
| 1258 void ParamTraits<ViewMsg_ExtensionExtentInfo>::Write(Message* m, |
| 1259 const param_type& p) { |
| 1260 WriteParam(m, p.extension_id); |
| 1261 WriteParam(m, p.web_extent); |
| 1262 WriteParam(m, p.browse_extent); |
| 1263 } |
| 1264 |
| 1265 bool ParamTraits<ViewMsg_ExtensionExtentInfo>::Read(const Message* m, |
| 1266 void** iter, |
| 1267 param_type* p) { |
| 1268 return ReadParam(m, iter, &p->extension_id) && |
| 1269 ReadParam(m, iter, &p->web_extent) && |
| 1270 ReadParam(m, iter, &p->browse_extent); |
| 1271 } |
| 1272 |
| 1273 void ParamTraits<ViewMsg_ExtensionExtentInfo>::Log(const param_type& p, |
| 1274 std::string* l) { |
| 1275 LogParam(p.extension_id, l); |
| 1276 } |
| 1277 |
| 1278 void ParamTraits<ViewMsg_ExtensionExtentsUpdated_Params>::Write( |
| 1279 Message* m, |
| 1280 const param_type& p) { |
| 1281 WriteParam(m, p.extension_apps); |
| 1282 } |
| 1283 |
| 1284 bool ParamTraits<ViewMsg_ExtensionExtentsUpdated_Params>::Read( |
| 1285 const Message* m, |
| 1286 void** iter, |
| 1287 param_type* p) { |
| 1288 return ReadParam(m, iter, &p->extension_apps); |
| 1289 } |
| 1290 |
| 1291 void ParamTraits<ViewMsg_ExtensionExtentsUpdated_Params>::Log( |
| 1292 const param_type& p, |
| 1293 std::string* l) { |
| 1294 LogParam(p.extension_apps, l); |
| 1295 } |
| 1296 |
| 1297 void ParamTraits<ViewMsg_DeviceOrientationUpdated_Params>::Write( |
| 1298 Message* m, |
| 1299 const param_type& p) { |
| 1300 WriteParam(m, p.can_provide_alpha); |
| 1301 WriteParam(m, p.alpha); |
| 1302 WriteParam(m, p.can_provide_beta); |
| 1303 WriteParam(m, p.beta); |
| 1304 WriteParam(m, p.can_provide_gamma); |
| 1305 WriteParam(m, p.gamma); |
| 1306 } |
| 1307 |
| 1308 bool ParamTraits<ViewMsg_DeviceOrientationUpdated_Params>::Read( |
| 1309 const Message* m, |
| 1310 void** iter, |
| 1311 param_type* p) { |
| 1312 return |
| 1313 ReadParam(m, iter, &p->can_provide_alpha) && |
| 1314 ReadParam(m, iter, &p->alpha) && |
| 1315 ReadParam(m, iter, &p->can_provide_beta) && |
| 1316 ReadParam(m, iter, &p->beta) && |
| 1317 ReadParam(m, iter, &p->can_provide_gamma) && |
| 1318 ReadParam(m, iter, &p->gamma); |
| 1319 } |
| 1320 |
| 1321 void ParamTraits<ViewMsg_DeviceOrientationUpdated_Params>::Log( |
| 1322 const param_type& p, |
| 1323 std::string* l) { |
| 1324 l->append("("); |
| 1325 LogParam(p.can_provide_alpha, l); |
| 1326 l->append(", "); |
| 1327 LogParam(p.alpha, l); |
| 1328 l->append(", "); |
| 1329 LogParam(p.can_provide_beta, l); |
| 1330 l->append(", "); |
| 1331 LogParam(p.beta, l); |
| 1332 l->append(", "); |
| 1333 LogParam(p.can_provide_gamma, l); |
| 1334 l->append(", "); |
| 1335 LogParam(p.gamma, l); |
| 1336 l->append(")"); |
| 1337 } |
| 1338 |
| 1339 void ParamTraits<ViewHostMsg_DomMessage_Params>::Write(Message* m, |
| 1340 const param_type& p) { |
| 1341 WriteParam(m, p.name); |
| 1342 WriteParam(m, p.arguments); |
| 1343 WriteParam(m, p.source_url); |
| 1344 WriteParam(m, p.request_id); |
| 1345 WriteParam(m, p.has_callback); |
| 1346 WriteParam(m, p.user_gesture); |
| 1347 } |
| 1348 |
| 1349 bool ParamTraits<ViewHostMsg_DomMessage_Params>::Read(const Message* m, |
| 1350 void** iter, |
| 1351 param_type* p) { |
| 1352 return |
| 1353 ReadParam(m, iter, &p->name) && |
| 1354 ReadParam(m, iter, &p->arguments) && |
| 1355 ReadParam(m, iter, &p->source_url) && |
| 1356 ReadParam(m, iter, &p->request_id) && |
| 1357 ReadParam(m, iter, &p->has_callback) && |
| 1358 ReadParam(m, iter, &p->user_gesture); |
| 1359 } |
| 1360 |
| 1361 void ParamTraits<ViewHostMsg_DomMessage_Params>::Log(const param_type& p, |
| 1362 std::string* l) { |
| 1363 l->append("("); |
| 1364 LogParam(p.name, l); |
| 1365 l->append(", "); |
| 1366 LogParam(p.arguments, l); |
| 1367 l->append(", "); |
| 1368 LogParam(p.source_url, l); |
| 1369 l->append(", "); |
| 1370 LogParam(p.request_id, l); |
| 1371 l->append(", "); |
| 1372 LogParam(p.has_callback, l); |
| 1373 l->append(", "); |
| 1374 LogParam(p.user_gesture, l); |
| 1375 l->append(")"); |
| 1376 } |
| 1377 |
| 1378 void ParamTraits<ViewHostMsg_OpenFileSystemRequest_Params>::Write( |
| 1379 Message* m, |
| 1380 const param_type& p) { |
| 1381 WriteParam(m, p.routing_id); |
| 1382 WriteParam(m, p.request_id); |
| 1383 WriteParam(m, p.origin_url); |
| 1384 WriteParam(m, p.type); |
| 1385 WriteParam(m, p.requested_size); |
| 1386 } |
| 1387 |
| 1388 bool ParamTraits<ViewHostMsg_OpenFileSystemRequest_Params>::Read( |
| 1389 const Message* m, |
| 1390 void** iter, |
| 1391 param_type* p) { |
| 1392 return |
| 1393 ReadParam(m, iter, &p->routing_id) && |
| 1394 ReadParam(m, iter, &p->request_id) && |
| 1395 ReadParam(m, iter, &p->origin_url) && |
| 1396 ReadParam(m, iter, &p->type) && |
| 1397 ReadParam(m, iter, &p->requested_size); |
| 1398 } |
| 1399 |
| 1400 void ParamTraits<ViewHostMsg_OpenFileSystemRequest_Params>::Log( |
| 1401 const param_type& p, |
| 1402 std::string* l) { |
| 1403 l->append("("); |
| 1404 LogParam(p.routing_id, l); |
| 1405 l->append(", "); |
| 1406 LogParam(p.request_id, l); |
| 1407 l->append(", "); |
| 1408 LogParam(p.origin_url, l); |
| 1409 l->append(", "); |
| 1410 LogParam(p.type, l); |
| 1411 l->append(", "); |
| 1412 LogParam(p.requested_size, l); |
| 1413 l->append(")"); |
| 1414 } |
| 1415 |
| 1416 } // namespace IPC |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3119035:
FBTF: Move individual XXXMsg_Params structs to a new file. (Closed)
Base URL: http://src.chromium.org/git/chromium.git