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#include "chrome/common/common_param_traits.h" 6#include "content/common/common_param_traits.h" 7 8#define IPC_MESSAGE_IMPL 9#include "chrome/common/automation_messages.h" 10 11AutomationURLRequest::AutomationURLRequest() 12 : resource_type(0), 13 load_flags(0) { 14} 15 16AutomationURLRequest::AutomationURLRequest( 17 const std::string& in_url, 18 const std::string& in_method, 19 const std::string& in_referrer, 20 const std::string& in_extra_request_headers, 21 scoped_refptr<net::UploadData> in_upload_data, 22 int in_resource_type, 23 int in_load_flags) 24 : url(in_url), 25 method(in_method), 26 referrer(in_referrer), 27 extra_request_headers(in_extra_request_headers), 28 upload_data(in_upload_data), 29 resource_type(in_resource_type), 30 load_flags(in_load_flags) { 31} 32 33AutomationURLRequest::~AutomationURLRequest() {} 34 35AutomationURLResponse::AutomationURLResponse() 36 : content_length(0), 37 redirect_status(0) { 38} 39 40AutomationURLResponse::AutomationURLResponse( 41 const std::string& in_mime_type, const std::string& in_headers, 42 int64 in_content_length, const base::Time& in_last_modified, 43 const std::string& in_redirect_url, int in_redirect_status, 44 const net::HostPortPair& host_socket_address) 45 : mime_type(in_mime_type), 46 headers(in_headers), 47 content_length(in_content_length), 48 last_modified(in_last_modified), 49 redirect_url(in_redirect_url), 50 redirect_status(in_redirect_status), 51 socket_address(host_socket_address) { 52} 53 54 55AutomationURLResponse::~AutomationURLResponse() {} 56 57ExternalTabSettings::ExternalTabSettings() 58 : parent(NULL), 59 dimensions(), 60 style(0), 61 is_incognito(false), 62 load_requests_via_automation(false), 63 handle_top_level_requests(false), 64 initial_url(), 65 referrer(), 66 infobars_enabled(false), 67 route_all_top_level_navigations(false) { 68} 69 70ExternalTabSettings::ExternalTabSettings( 71 gfx::NativeWindow in_parent, 72 const gfx::Rect& in_dimensions, 73 unsigned int in_style, 74 bool in_is_incognito, 75 bool in_load_requests_via_automation, 76 bool in_handle_top_level_requests, 77 const GURL& in_initial_url, 78 const GURL& in_referrer, 79 bool in_infobars_enabled, 80 bool in_route_all_top_level_navigations) 81 : parent(in_parent), 82 dimensions(in_dimensions), 83 style(in_style), 84 is_incognito(in_is_incognito), 85 load_requests_via_automation(in_load_requests_via_automation), 86 handle_top_level_requests(in_handle_top_level_requests), 87 initial_url(in_initial_url), 88 referrer(in_referrer), 89 infobars_enabled(in_infobars_enabled), 90 route_all_top_level_navigations(in_route_all_top_level_navigations) { 91} 92 93ExternalTabSettings::~ExternalTabSettings() {} 94 95NavigationInfo::NavigationInfo() 96 : navigation_type(0), 97 relative_offset(0), 98 navigation_index(0), 99 security_style(SECURITY_STYLE_UNKNOWN), 100 displayed_insecure_content(0), 101 ran_insecure_content(0) { 102} 103 104NavigationInfo::NavigationInfo(int in_navigation_type, 105 int in_relative_offset, 106 int in_navigation_index, 107 const std::wstring& in_title, 108 const GURL& in_url, 109 const GURL& in_referrer, 110 SecurityStyle in_security_style, 111 bool in_displayed_insecure_content, 112 bool in_ran_insecure_content) 113 : navigation_type(in_navigation_type), 114 relative_offset(in_relative_offset), 115 navigation_index(in_navigation_index), 116 title(in_title), 117 url(in_url), 118 referrer(in_referrer), 119 security_style(in_security_style), 120 displayed_insecure_content(in_displayed_insecure_content), 121 ran_insecure_content(in_ran_insecure_content) { 122} 123 124NavigationInfo::~NavigationInfo() {} 125 126MiniContextMenuParams::MiniContextMenuParams() 127 : screen_x(0), 128 screen_y(0) { 129} 130 131MiniContextMenuParams::MiniContextMenuParams(int in_screen_x, 132 int in_screen_y, 133 const GURL& in_link_url, 134 const GURL& in_unfiltered_link_url, 135 const GURL& in_src_url, 136 const GURL& in_page_url, 137 const GURL& in_frame_url) 138 : screen_x(in_screen_x), 139 screen_y(in_screen_y), 140 link_url(in_link_url), 141 unfiltered_link_url(in_unfiltered_link_url), 142 src_url(in_src_url), 143 page_url(in_page_url), 144 frame_url(in_frame_url) { 145} 146 147MiniContextMenuParams::~MiniContextMenuParams() {} 148 149AttachExternalTabParams::AttachExternalTabParams() 150 : cookie(0), 151 disposition(0), 152 user_gesture(false) { 153} 154 155AttachExternalTabParams::AttachExternalTabParams( 156 uint64 in_cookie, 157 const GURL& in_url, 158 const gfx::Rect& in_dimensions, 159 int in_disposition, 160 bool in_user_gesture, 161 const std::string& in_profile_name) 162 : cookie(in_cookie), 163 url(in_url), 164 dimensions(in_dimensions), 165 disposition(in_disposition), 166 user_gesture(in_user_gesture), 167 profile_name(in_profile_name) { 168} 169 170AttachExternalTabParams::~AttachExternalTabParams() {} 171 172namespace IPC { 173 174// static 175void ParamTraits<AutomationMsg_Find_Params>::Write(Message* m, 176 const param_type& p) { 177 WriteParam(m, p.unused); 178 WriteParam(m, p.search_string); 179 WriteParam(m, p.forward); 180 WriteParam(m, p.match_case); 181 WriteParam(m, p.find_next); 182} 183 184// static 185bool ParamTraits<AutomationMsg_Find_Params>::Read(const Message* m, 186 void** iter, 187 param_type* p) { 188 return 189 ReadParam(m, iter, &p->unused) && 190 ReadParam(m, iter, &p->search_string) && 191 ReadParam(m, iter, &p->forward) && 192 ReadParam(m, iter, &p->match_case) && 193 ReadParam(m, iter, &p->find_next); 194} 195 196// static 197void ParamTraits<AutomationMsg_Find_Params>::Log(const param_type& p, 198 std::string* l) { 199 l->append("<AutomationMsg_Find_Params>"); 200} 201 202// static 203void ParamTraits<AutomationMsg_NavigationResponseValues>::Write( 204 Message* m, 205 const param_type& p) { 206 m->WriteInt(p); 207} 208 209// static 210bool ParamTraits<AutomationMsg_NavigationResponseValues>::Read(const Message* m, 211 void** iter, 212 param_type* p) { 213 int type; 214 if (!m->ReadInt(iter, &type)) 215 return false; 216 *p = static_cast<AutomationMsg_NavigationResponseValues>(type); 217 return true; 218} 219 220// static 221void ParamTraits<AutomationMsg_NavigationResponseValues>::Log( 222 const param_type& p, std::string* l) { 223 std::string control; 224 switch (p) { 225 case AUTOMATION_MSG_NAVIGATION_ERROR: 226 control = "AUTOMATION_MSG_NAVIGATION_ERROR"; 227 break; 228 case AUTOMATION_MSG_NAVIGATION_SUCCESS: 229 control = "AUTOMATION_MSG_NAVIGATION_SUCCESS"; 230 break; 231 case AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED: 232 control = "AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED"; 233 break; 234 default: 235 control = "UNKNOWN"; 236 break; 237 } 238 239 LogParam(control, l); 240} 241 242// static 243void ParamTraits<AutomationMsg_ExtensionResponseValues>::Write( 244 Message* m, 245 const param_type& p) { 246 m->WriteInt(p); 247} 248 249// static 250bool ParamTraits<AutomationMsg_ExtensionResponseValues>::Read( 251 const Message* m, 252 void** iter, 253 param_type* p) { 254 int type; 255 if (!m->ReadInt(iter, &type)) 256 return false; 257 *p = static_cast<AutomationMsg_ExtensionResponseValues>(type); 258 return true; 259} 260 261// static 262void ParamTraits<AutomationMsg_ExtensionResponseValues>::Log( 263 const param_type& p, 264 std::string* l) { 265 std::string control; 266 switch (p) { 267 case AUTOMATION_MSG_EXTENSION_INSTALL_SUCCEEDED: 268 control = "AUTOMATION_MSG_EXTENSION_INSTALL_SUCCEEDED"; 269 break; 270 case AUTOMATION_MSG_EXTENSION_INSTALL_FAILED: 271 control = "AUTOMATION_MSG_EXTENSION_INSTALL_FAILED"; 272 break; 273 default: 274 control = "UNKNOWN"; 275 break; 276 } 277 278 LogParam(control, l); 279} 280 281// static 282void ParamTraits<AutomationMsg_ExtensionProperty>::Write(Message* m, 283 const param_type& p) { 284 m->WriteInt(p); 285} 286 287// static 288bool ParamTraits<AutomationMsg_ExtensionProperty>::Read(const Message* m, 289 void** iter, 290 param_type* p) { 291 int type; 292 if (!m->ReadInt(iter, &type)) 293 return false; 294 *p = static_cast<AutomationMsg_ExtensionProperty>(type); 295 return true; 296} 297 298// static 299void ParamTraits<AutomationMsg_ExtensionProperty>::Log(const param_type& p, 300 std::string* l) { 301 std::string control; 302 switch (p) { 303 case AUTOMATION_MSG_EXTENSION_ID: 304 control = "AUTOMATION_MSG_EXTENSION_ID"; 305 break; 306 case AUTOMATION_MSG_EXTENSION_NAME: 307 control = "AUTOMATION_MSG_EXTENSION_NAME"; 308 break; 309 case AUTOMATION_MSG_EXTENSION_VERSION: 310 control = "AUTOMATION_MSG_EXTENSION_VERSION"; 311 break; 312 case AUTOMATION_MSG_EXTENSION_BROWSER_ACTION_INDEX: 313 control = "AUTOMATION_MSG_EXTENSION_BROWSER_ACTION_INDEX"; 314 break; 315 default: 316 control = "UNKNOWN"; 317 break; 318 } 319 320 LogParam(control, l); 321} 322 323// static 324void ParamTraits<SecurityStyle>::Write(Message* m, const param_type& p) { 325 m->WriteInt(p); 326} 327 328// static 329bool ParamTraits<SecurityStyle>::Read(const Message* m, 330 void** iter, 331 param_type* p) { 332 int type; 333 if (!m->ReadInt(iter, &type)) 334 return false; 335 *p = static_cast<SecurityStyle>(type); 336 return true; 337} 338 339// static 340void ParamTraits<SecurityStyle>::Log(const param_type& p, std::string* l) { 341 std::string control; 342 switch (p) { 343 case SECURITY_STYLE_UNKNOWN: 344 control = "SECURITY_STYLE_UNKNOWN"; 345 break; 346 case SECURITY_STYLE_UNAUTHENTICATED: 347 control = "SECURITY_STYLE_UNAUTHENTICATED"; 348 break; 349 case SECURITY_STYLE_AUTHENTICATION_BROKEN: 350 control = "SECURITY_STYLE_AUTHENTICATION_BROKEN"; 351 break; 352 case SECURITY_STYLE_AUTHENTICATED: 353 control = "SECURITY_STYLE_AUTHENTICATED"; 354 break; 355 default: 356 control = "UNKNOWN"; 357 break; 358 } 359 360 LogParam(control, l); 361} 362 363// static 364void ParamTraits<PageType>::Write(Message* m, const param_type& p) { 365 m->WriteInt(p); 366} 367 368// static 369bool ParamTraits<PageType>::Read(const Message* m, void** iter, param_type* p) { 370 int type; 371 if (!m->ReadInt(iter, &type)) 372 return false; 373 *p = static_cast<PageType>(type); 374 return true; 375} 376 377// static 378void ParamTraits<PageType>::Log(const param_type& p, std::string* l) { 379 std::string control; 380 switch (p) { 381 case NORMAL_PAGE: 382 control = "NORMAL_PAGE"; 383 break; 384 case ERROR_PAGE: 385 control = "ERROR_PAGE"; 386 break; 387 case INTERSTITIAL_PAGE: 388 control = "INTERSTITIAL_PAGE"; 389 break; 390 default: 391 control = "UNKNOWN"; 392 break; 393 } 394 395 LogParam(control, l); 396} 397 398// static 399void ParamTraits<AutomationURLRequest>::Write(Message* m, const param_type& p) { 400 WriteParam(m, p.url); 401 WriteParam(m, p.method); 402 WriteParam(m, p.referrer); 403 WriteParam(m, p.extra_request_headers); 404 WriteParam(m, p.upload_data); 405 WriteParam(m, p.resource_type); 406 WriteParam(m, p.load_flags); 407} 408 409// static 410bool ParamTraits<AutomationURLRequest>::Read(const Message* m, 411 void** iter, 412 param_type* p) { 413 return ReadParam(m, iter, &p->url) && 414 ReadParam(m, iter, &p->method) && 415 ReadParam(m, iter, &p->referrer) && 416 ReadParam(m, iter, &p->extra_request_headers) && 417 ReadParam(m, iter, &p->upload_data) && 418 ReadParam(m, iter, &p->resource_type) && 419 ReadParam(m, iter, &p->load_flags); 420} 421 422// static 423void ParamTraits<AutomationURLRequest>::Log(const param_type& p, 424 std::string* l) { 425 l->append("("); 426 LogParam(p.url, l); 427 l->append(", "); 428 LogParam(p.method, l); 429 l->append(", "); 430 LogParam(p.referrer, l); 431 l->append(", "); 432 LogParam(p.extra_request_headers, l); 433 l->append(", "); 434 LogParam(p.upload_data, l); 435 l->append(", "); 436 LogParam(p.resource_type, l); 437 l->append(", "); 438 LogParam(p.load_flags, l); 439 l->append(")"); 440} 441 442// static 443void ParamTraits<AutomationURLResponse>::Write(Message* m, 444 const param_type& p) { 445 WriteParam(m, p.mime_type); 446 WriteParam(m, p.headers); 447 WriteParam(m, p.content_length); 448 WriteParam(m, p.last_modified); 449 WriteParam(m, p.redirect_url); 450 WriteParam(m, p.redirect_status); 451 WriteParam(m, p.socket_address); 452} 453 454// static 455bool ParamTraits<AutomationURLResponse>::Read(const Message* m, 456 void** iter, 457 param_type* p) { 458 return ReadParam(m, iter, &p->mime_type) && 459 ReadParam(m, iter, &p->headers) && 460 ReadParam(m, iter, &p->content_length) && 461 ReadParam(m, iter, &p->last_modified) && 462 ReadParam(m, iter, &p->redirect_url) && 463 ReadParam(m, iter, &p->redirect_status) && 464 ReadParam(m, iter, &p->socket_address); 465} 466 467// static 468void ParamTraits<AutomationURLResponse>::Log(const param_type& p, 469 std::string* l) { 470 l->append("("); 471 LogParam(p.mime_type, l); 472 l->append(", "); 473 LogParam(p.headers, l); 474 l->append(", "); 475 LogParam(p.content_length, l); 476 l->append(", "); 477 LogParam(p.last_modified, l); 478 l->append(", "); 479 LogParam(p.redirect_url, l); 480 l->append(", "); 481 LogParam(p.redirect_status, l); 482 l->append(", "); 483 LogParam(p.socket_address, l); 484 l->append(")"); 485} 486 487// static 488void ParamTraits<ExternalTabSettings>::Write(Message* m, 489 const param_type& p) { 490 WriteParam(m, p.parent); 491 WriteParam(m, p.dimensions); 492 WriteParam(m, p.style); 493 WriteParam(m, p.is_incognito); 494 WriteParam(m, p.load_requests_via_automation); 495 WriteParam(m, p.handle_top_level_requests); 496 WriteParam(m, p.initial_url); 497 WriteParam(m, p.referrer); 498 WriteParam(m, p.infobars_enabled); 499 WriteParam(m, p.route_all_top_level_navigations); 500} 501 502// static 503bool ParamTraits<ExternalTabSettings>::Read(const Message* m, 504 void** iter, 505 param_type* p) { 506 return ReadParam(m, iter, &p->parent) && 507 ReadParam(m, iter, &p->dimensions) && 508 ReadParam(m, iter, &p->style) && 509 ReadParam(m, iter, &p->is_incognito) && 510 ReadParam(m, iter, &p->load_requests_via_automation) && 511 ReadParam(m, iter, &p->handle_top_level_requests) && 512 ReadParam(m, iter, &p->initial_url) && 513 ReadParam(m, iter, &p->referrer) && 514 ReadParam(m, iter, &p->infobars_enabled) && 515 ReadParam(m, iter, &p->route_all_top_level_navigations); 516} 517 518// static 519void ParamTraits<ExternalTabSettings>::Log(const param_type& p, 520 std::string* l) { 521 l->append("("); 522 LogParam(p.parent, l); 523 l->append(", "); 524 LogParam(p.dimensions, l); 525 l->append(", "); 526 LogParam(p.style, l); 527 l->append(", "); 528 LogParam(p.is_incognito, l); 529 l->append(", "); 530 LogParam(p.load_requests_via_automation, l); 531 l->append(", "); 532 LogParam(p.handle_top_level_requests, l); 533 l->append(", "); 534 LogParam(p.initial_url, l); 535 l->append(", "); 536 LogParam(p.referrer, l); 537 l->append(", "); 538 LogParam(p.infobars_enabled, l); 539 l->append(", "); 540 LogParam(p.route_all_top_level_navigations, l); 541 l->append(")"); 542} 543 544// static 545void ParamTraits<NavigationInfo>::Write(Message* m, const param_type& p) { 546 WriteParam(m, p.navigation_type); 547 WriteParam(m, p.relative_offset); 548 WriteParam(m, p.navigation_index); 549 WriteParam(m, p.title); 550 WriteParam(m, p.url); 551 WriteParam(m, p.referrer); 552 WriteParam(m, p.security_style); 553 WriteParam(m, p.displayed_insecure_content); 554 WriteParam(m, p.ran_insecure_content); 555} 556 557// static 558bool ParamTraits<NavigationInfo>::Read(const Message* m, 559 void** iter, 560 param_type* p) { 561 return ReadParam(m, iter, &p->navigation_type) && 562 ReadParam(m, iter, &p->relative_offset) && 563 ReadParam(m, iter, &p->navigation_index) && 564 ReadParam(m, iter, &p->title) && 565 ReadParam(m, iter, &p->url) && 566 ReadParam(m, iter, &p->referrer) && 567 ReadParam(m, iter, &p->security_style) && 568 ReadParam(m, iter, &p->displayed_insecure_content) && 569 ReadParam(m, iter, &p->ran_insecure_content); 570} 571 572// static 573void ParamTraits<NavigationInfo>::Log(const param_type& p, std::string* l) { 574 l->append("("); 575 LogParam(p.navigation_type, l); 576 l->append(", "); 577 LogParam(p.relative_offset, l); 578 l->append(", "); 579 LogParam(p.navigation_index, l); 580 l->append(", "); 581 LogParam(p.title, l); 582 l->append(", "); 583 LogParam(p.url, l); 584 l->append(", "); 585 LogParam(p.referrer, l); 586 l->append(", "); 587 LogParam(p.security_style, l); 588 l->append(", "); 589 LogParam(p.displayed_insecure_content, l); 590 l->append(", "); 591 LogParam(p.ran_insecure_content, l); 592 l->append(")"); 593} 594 595// static 596void ParamTraits<MiniContextMenuParams>::Write(Message* m, 597 const param_type& p) { 598 WriteParam(m, p.screen_x); 599 WriteParam(m, p.screen_y); 600 WriteParam(m, p.link_url); 601 WriteParam(m, p.unfiltered_link_url); 602 WriteParam(m, p.src_url); 603 WriteParam(m, p.page_url); 604 WriteParam(m, p.frame_url); 605} 606 607// static 608bool ParamTraits<MiniContextMenuParams>::Read(const Message* m, 609 void** iter, 610 param_type* p) { 611 return ReadParam(m, iter, &p->screen_x) && 612 ReadParam(m, iter, &p->screen_y) && 613 ReadParam(m, iter, &p->link_url) && 614 ReadParam(m, iter, &p->unfiltered_link_url) && 615 ReadParam(m, iter, &p->src_url) && 616 ReadParam(m, iter, &p->page_url) && 617 ReadParam(m, iter, &p->frame_url); 618} 619 620// static 621void ParamTraits<MiniContextMenuParams>::Log(const param_type& p, 622 std::string* l) { 623 l->append("("); 624 LogParam(p.screen_x, l); 625 l->append(", "); 626 LogParam(p.screen_y, l); 627 l->append(", "); 628 LogParam(p.link_url, l); 629 l->append(", "); 630 LogParam(p.unfiltered_link_url, l); 631 l->append(", "); 632 LogParam(p.src_url, l); 633 l->append(", "); 634 LogParam(p.page_url, l); 635 l->append(", "); 636 LogParam(p.frame_url, l); 637 l->append(")"); 638} 639 640// static 641void ParamTraits<AttachExternalTabParams>::Write(Message* m, 642 const param_type& p) { 643 WriteParam(m, p.cookie); 644 WriteParam(m, p.url); 645 WriteParam(m, p.dimensions); 646 WriteParam(m, p.disposition); 647 WriteParam(m, p.user_gesture); 648 WriteParam(m, p.profile_name); 649} 650 651// static 652bool ParamTraits<AttachExternalTabParams>::Read(const Message* m, 653 void** iter, 654 param_type* p) { 655 return ReadParam(m, iter, &p->cookie) && 656 ReadParam(m, iter, &p->url) && 657 ReadParam(m, iter, &p->dimensions) && 658 ReadParam(m, iter, &p->disposition) && 659 ReadParam(m, iter, &p->user_gesture) && 660 ReadParam(m, iter, &p->profile_name); 661} 662 663// static 664void ParamTraits<AttachExternalTabParams>::Log(const param_type& p, 665 std::string* l) { 666 l->append("("); 667 LogParam(p.cookie, l); 668 l->append(", "); 669 LogParam(p.url, l); 670 l->append(", "); 671 LogParam(p.dimensions, l); 672 l->append(", "); 673 LogParam(p.disposition, l); 674 l->append(", "); 675 LogParam(p.user_gesture, l); 676 l->append(","); 677 LogParam(p.profile_name, l); 678 l->append(")"); 679} 680 681} // namespace IPC 682