Add chrome to the repository.

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@15 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 1548 insertions, 0 deletions

diff --git a/chrome/common/render_messages.h b/chrome/common/render_messages.h
new file mode 100644
index 0000000..32f7d7e
--- /dev/null
+++ b/chrome/common/render_messages.h
@@ -0,0 +1,1548 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef CHROME_COMMON_RENDER_MESSAGES_H__
+#define CHROME_COMMON_RENDER_MESSAGES_H__
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/ref_counted.h"
+#include "base/shared_memory.h"
+#include "chrome/common/filter_policy.h"
+#include "chrome/common/ipc_message.h"
+#include "chrome/common/ipc_message_utils.h"
+#include "chrome/common/page_transition_types.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/upload_data.h"
+#include "net/url_request/url_request_status.h"
+#include "webkit/glue/cache_manager.h"
+#include "webkit/glue/context_node_types.h"
+#include "webkit/glue/form_data.h"
+#include "webkit/glue/password_form.h"
+#include "webkit/glue/password_form_dom_manager.h"
+#include "webkit/glue/resource_loader_bridge.h"
+#include "webkit/glue/webdropdata.h"
+#include "webkit/glue/webplugin.h"
+#include "webkit/glue/webpreferences.h"
+#include "webkit/glue/webview_delegate.h"
+
+// Parameters structure for ViewMsg_Navigate, which has too many data
+// parameters to be reasonably put in a predefined IPC message.
+struct ViewMsg_Navigate_Params {
+  // The page_id for this navigation, or -1 if it is a new navigation.  Back,
+  // Forward, and Reload navigations should have a valid page_id.  If the load
+  // succeeds, then this page_id will be reflected in the resultant
+  // ViewHostMsg_FrameNavigate message.
+  int32 page_id;
+
+  // The URL to load.
+  GURL url;
+
+  // The type of transition.
+  PageTransition::Type transition;
+
+  // Opaque history state (received by ViewHostMsg_UpdateState).
+  std::string state;
+
+  // Specifies if the URL should be loaded using 'reload' semantics (i.e.,
+  // bypassing any locally cached content).
+  bool reload;
+};
+
+// Parameters structure for ViewHostMsg_FrameNavigate, which has too many data
+// parameters to be reasonably put in a predefined IPC message.
+struct ViewHostMsg_FrameNavigate_Params {
+  // Page ID of this navigation. The renderer creates a new unique page ID
+  // anytime a new session history entry is created. This means you'll get new
+  // page IDs for user actions, and the old page IDs will be reloaded when
+  // iframes are loaded automatically.
+  int32 page_id;
+
+  // URL of the page being loaded. NON-CANONICAL.
+  GURL url;
+
+  // URL of the referrer of this load. WebKit generates this based on the
+  // source of the event that caused the load. NON-CANONICAL.
+  GURL referrer;
+
+  // The type of transition.
+  PageTransition::Type transition;
+
+  // Lists the redirects that occurred on the way to the current page. This
+  // vector has the same format as reported by the WebDataSource in the glue,
+  // with the current page being the last one in the list (so even when
+  // there's no redirect, there will be one entry in the list.
+  std::vector<GURL> redirects;
+
+  // Set to false if we want to update the session history but not update
+  // the browser history.  E.g., on unreachable urls.
+  bool should_update_history;
+
+  // See SearchableFormData for a description of these.
+  GURL searchable_form_url;
+  std::wstring searchable_form_element_name;
+  std::string searchable_form_encoding;
+
+  // See password_form.h.
+  PasswordForm password_form;
+
+  // Information regarding the security of the connection (empty if the
+  // connection was not secure).
+  std::string security_info;
+
+  // The gesture that initiated this navigation.
+  NavigationGesture gesture;
+
+  // Contents MIME type of main frame.
+  std::string contents_mime_type;
+
+  // True if this was a post request.
+  bool is_post;
+};
+
+// Parameters structure for ViewHostMsg_ContextMenu, which has too many data
+// parameters to be reasonably put in a predefined IPC message.
+// FIXME(beng): This would be more useful in the future and more efficient
+//              if the parameters here weren't so literally mapped to what
+//              they contain for the ContextMenu task. It might be better
+//              to make the string fields more generic so that this object
+//              could be used for more contextual actions.
+struct ViewHostMsg_ContextMenu_Params {
+  // This is the type of Context Node that the context menu was invoked on.
+  ContextNode::Type type;
+
+  // These values represent the coordinates of the mouse when the context menu
+  // was invoked.  Coords are relative to the associated RenderView's origin.
+  int x;
+  int y;
+
+  // This is the URL of the link that encloses the node the context menu was
+  // invoked on.
+  GURL link_url;
+
+  // This is the URL of the image the context menu was invoked on.
+  GURL image_url;
+
+  // This is the URL of the top level page that the context menu was invoked
+  // on.
+  GURL page_url;
+
+  // This is the URL of the subframe that the context menu was invoked on.
+  GURL frame_url;
+
+  // This is the text of the selection that the context menu was invoked on.
+  std::wstring selection_text;
+
+  // The misspelled word under the cursor, if any. Used to generate the
+  // |dictionary_suggestions| list.
+  std::wstring misspelled_word;
+
+  // Suggested replacements for a misspelled word under the cursor.
+  // This vector gets populated in the render process host
+  // by intercepting ViewHostMsg_ContextMenu in ResourceMessageFilter
+  // and populating dictionary_suggestions if the type is EDITABLE
+  // and the misspelled_word is not empty.
+  std::vector<std::wstring> dictionary_suggestions;
+
+  // These flags indicate to the browser whether the renderer believes it is
+  // able to perform the corresponding action.
+  int edit_flags;
+};
+
+// Values that may be OR'd together to form the 'flags' parameter of a
+// ViewHostMsg_PaintRect message.
+struct ViewHostMsg_PaintRect_Flags {
+  enum {
+    IS_RESIZE_ACK = 1 << 0,
+    IS_RESTORE_ACK = 1 << 1,
+  };
+  static bool is_resize_ack(int flags) {
+    return (flags & IS_RESIZE_ACK) != 0;
+  }
+  static bool is_restore_ack(int flags) {
+    return (flags & IS_RESTORE_ACK) != 0;
+  }
+};
+
+struct ViewHostMsg_PaintRect_Params {
+  // The bitmap to be painted into the rect given by bitmap_rect.  Valid only
+  // in the context of the renderer process.
+  SharedMemoryHandle bitmap;
+
+  // The position and size of the bitmap.
+  gfx::Rect bitmap_rect;
+
+  // The size of the RenderView when this message was generated.  This is
+  // included so the host knows how large the view is from the perspective of
+  // the renderer process.  This is necessary in case a resize operation is in
+  // progress.
+  gfx::Size view_size;
+
+  // New window locations for plugin child windows.
+  std::vector<WebPluginGeometry> plugin_window_moves;
+
+  // The following describes the various bits that may be set in flags:
+  //
+  //   ViewHostMsg_PaintRect_Flags::IS_RESIZE_ACK
+  //     Indicates that this is a response to a ViewMsg_Resize message.
+  //
+  //   ViewHostMsg_PaintRect_Flags::IS_RESTORE_ACK
+  //     Indicates that this is a response to a ViewMsg_WasRestored message.
+  //
+  // If flags is zero, then this message corresponds to an unsoliticed paint
+  // request by the render view.  Both of the above bits may be set in flags,
+  // which would indicate that this paint message is an ACK for multiple
+  // request messages.
+  int flags;
+};
+
+// Parameters structure for ViewHostMsg_ScrollRect, which has too many data
+// parameters to be reasonably put in a predefined IPC message.
+struct ViewHostMsg_ScrollRect_Params {
+  // The bitmap to be painted into the rect exposed by scrolling.  This handle
+  // is valid only in the context of the renderer process.
+  SharedMemoryHandle bitmap;
+
+  // The position and size of the bitmap.
+  gfx::Rect bitmap_rect;
+
+  // The scroll offset.  Only one of these can be non-zero.
+  int dx;
+  int dy;
+
+  // The rectangular region to scroll.
+  gfx::Rect clip_rect;
+
+  // The size of the RenderView when this message was generated.
+  gfx::Size view_size;
+
+  // New window locations for plugin child windows.
+  std::vector<WebPluginGeometry> plugin_window_moves;
+};
+
+// Parameters structure for ViewMsg_UploadFile.
+struct ViewMsg_UploadFile_Params {
+  // See WebContents::StartFileUpload for a description of these fields.
+  std::wstring file_path;
+  std::wstring form;
+  std::wstring file;
+  std::wstring submit;
+  std::wstring other_values;
+};
+
+// Parameters for a resource request.
+struct ViewHostMsg_Resource_Request {
+  // The request method: GET, POST, etc.
+  std::string method;
+
+  // The requested URL.
+  GURL url;
+
+  // The URL of the document in the top-level window, which may be checked by
+  // the third-party cookie blocking policy. Leaving it empty may lead to
+  // undesired cookie blocking. Third-party cookie blocking can be bypassed by
+  // setting policy_url = url, but this should ideally only be done if there
+  // really is no way to determine the correct value.
+  GURL policy_url;
+
+  // The referrer to use (may be empty).
+  GURL referrer;
+
+  // Additional HTTP request headers.
+  std::string headers;
+
+  // URLRequest load flags (0 by default).
+  int load_flags;
+
+  // Process ID of process that originated this request.
+  int origin_pid;
+
+  // What this resource load is for (main frame, sub-frame, sub-resource,
+  // object).
+  ResourceType::Type resource_type;
+
+  // True if this request is for a resource loaded over HTTP when the main page
+  // was loaded over HTTPS.
+  bool mixed_content;
+
+  // Used by plugin->browser requests to get the correct URLRequestContext.
+  uint32 request_context;
+
+  // Optional upload data (may be empty).
+  std::vector<net::UploadData::Element> upload_content;
+};
+
+// Parameters for a resource response header.
+struct ViewMsg_Resource_ResponseHead :
+    webkit_glue::ResourceLoaderBridge::ResponseInfo {
+  // The response status.
+  URLRequestStatus status;
+
+  // Specifies if the resource should be filtered before being displayed
+  // (insecure resources can be filtered to keep the page secure).
+  FilterPolicy::Type filter_policy;
+};
+
+// Parameters for a synchronous resource response.
+struct ViewHostMsg_SyncLoad_Result : ViewMsg_Resource_ResponseHead {
+  // The final URL after any redirects.
+  GURL final_url;
+
+  // The response data.
+  std::string data;
+};
+
+// Parameters for a render request.
+struct ViewMsg_Print_Params {
+  // In pixels according to dpi_x and dpi_y.
+  gfx::Size printable_size;
+
+  // Specifies dots per inch.
+  double dpi;
+
+  // Minimum shrink factor. See PrintSettings::min_shrink for more information.
+  double min_shrink;
+
+  // Maximum shrink factor. See PrintSettings::max_shrink for more information.
+  double max_shrink;
+
+  // Desired apparent dpi on paper.
+  int desired_dpi;
+
+  // Cookie for the document to ensure correctness.
+  int document_cookie;
+
+  // Warning: do not compare document_cookie.
+  bool Equals(const ViewMsg_Print_Params& rhs) const {
+    return printable_size == rhs.printable_size &&
+           dpi == rhs.dpi &&
+           min_shrink == rhs.min_shrink &&
+           max_shrink == rhs.max_shrink &&
+           desired_dpi == rhs.desired_dpi;
+  }
+};
+
+struct ViewMsg_PrintPage_Params {
+  // Parameters to render the page as a printed page. It must always be the same
+  // value for all the document.
+  ViewMsg_Print_Params params;
+
+  // The page number is the indicator of the square that should be rendered
+  // according to the layout specified in ViewMsg_Print_Params.
+  int page_number;
+};
+
+struct ViewMsg_PrintPages_Params {
+  // Parameters to render the page as a printed page. It must always be the same
+  // value for all the document.
+  ViewMsg_Print_Params params;
+
+  // If empty, this means a request to render all the printed pages.
+  std::vector<int> pages;
+};
+
+// Parameters to describe a rendered page.
+struct ViewHostMsg_DidPrintPage_Params {
+  // A shared memory handle to the EMF data. This data can be quite large so a
+  // memory map needs to be used.
+  SharedMemoryHandle emf_data_handle;
+
+  // Size of the EMF data.
+  unsigned data_size;
+
+  // Cookie for the document to ensure correctness.
+  int document_cookie;
+
+  // Page number.
+  int page_number;
+
+  // Shrink factor used to render this page.
+  double actual_shrink;
+};
+
+// The first parameter for the ViewHostMsg_ImeUpdateStatus message.
+enum ViewHostMsg_ImeControl {
+  IME_DISABLE = 0,
+  IME_MOVE_WINDOWS,
+  IME_COMPLETE_COMPOSITION,
+};
+
+// Multi-pass include of render_messages_internal.  Preprocessor magic allows
+// us to use 1 header to define the enums and classes for our render messages.
+#define IPC_MESSAGE_MACROS_ENUMS
+#include "chrome/common/render_messages_internal.h"
+
+#ifdef IPC_MESSAGE_MACROS_LOG_ENABLED
+// When we are supposed to create debug strings, we run it through twice, once
+// with debug strings on, and once with only CLASSES on to generate both types
+// of messages.
+#  undef IPC_MESSAGE_MACROS_LOG
+#  define IPC_MESSAGE_MACROS_CLASSES
+#  include "chrome/common/render_messages_internal.h"
+
+#  undef IPC_MESSAGE_MACROS_CLASSES
+#  define IPC_MESSAGE_MACROS_LOG
+#  include "chrome/common/render_messages_internal.h"
+#else
+// No debug strings requested, just define the classes
+#  define IPC_MESSAGE_MACROS_CLASSES
+#  include "chrome/common/render_messages_internal.h"
+#endif
+
+
+namespace IPC {
+
+template <>
+struct ParamTraits<ResourceType::Type> {
+  typedef ResourceType::Type param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type) || !ResourceType::ValidType(type))
+      return false;
+    *p = ResourceType::FromInt(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring type;
+    switch(p) {
+      case ResourceType::MAIN_FRAME:
+        type = L"MAIN_FRAME";
+       break;
+     case ResourceType::SUB_FRAME:
+       type = L"SUB_FRAME";
+       break;
+     case ResourceType::SUB_RESOURCE:
+       type = L"SUB_RESOURCE";
+       break;
+     case ResourceType::OBJECT:
+       type = L"OBJECT";
+       break;
+     default:
+       type = L"UNKNOWN";
+       break;
+    }
+
+    LogParam(type, l);
+  }
+};
+
+template <>
+struct ParamTraits<FilterPolicy::Type> {
+  typedef FilterPolicy::Type param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type) || !FilterPolicy::ValidType(type))
+      return false;
+    *p = FilterPolicy::FromInt(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring type;
+    switch(p) {
+      case FilterPolicy::DONT_FILTER:
+        type = L"DONT_FILTER";
+        break;
+      case FilterPolicy::FILTER_ALL:
+        type = L"FILTER_ALL";
+        break;
+      case FilterPolicy::FILTER_ALL_EXCEPT_IMAGES:
+        type = L"FILTER_ALL_EXCEPT_IMAGES";
+        break;
+      default:
+        type = L"UNKNOWN";
+        break;
+    }
+
+    LogParam(type, l);
+  }
+};
+
+template <>
+struct ParamTraits<ContextNode::Type> {
+  typedef ContextNode::Type param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type))
+      return false;
+    *p = ContextNode::FromInt(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring type;
+    switch(p) {
+     case WebInputEvent::MOUSE_DOWN:
+      type = L"MOUSE_DOWN";
+      break;
+     case WebInputEvent::MOUSE_UP:
+      type = L"MOUSE_UP";
+      break;
+     case WebInputEvent::MOUSE_MOVE:
+      type = L"MOUSE_MOVE";
+      break;
+     case WebInputEvent::MOUSE_LEAVE:
+      type = L"MOUSE_LEAVE";
+      break;
+     case WebInputEvent::MOUSE_DOUBLE_CLICK:
+      type = L"MOUSE_DOUBLE_CLICK";
+      break;
+     case WebInputEvent::MOUSE_WHEEL:
+      type = L"MOUSE_WHEEL";
+      break;
+     case WebInputEvent::KEY_DOWN:
+      type = L"KEY_DOWN";
+      break;
+     case WebInputEvent::KEY_UP:
+      type = L"KEY_UP";
+      break;
+     default:
+      type = L"UNKNOWN";
+      break;
+    }
+
+    LogParam(type, l);
+  }
+};
+
+template <>
+struct ParamTraits<WebInputEvent::Type> {
+  typedef WebInputEvent::Type param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type))
+      return false;
+    *p = static_cast<WebInputEvent::Type>(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring event;
+    switch(p) {
+     case ContextNode::NONE:
+      event = L"NONE";
+      break;
+     case ContextNode::PAGE:
+      event = L"PAGE";
+      break;
+     case ContextNode::FRAME:
+      event = L"FRAME";
+      break;
+     case ContextNode::LINK:
+      event = L"LINK";
+      break;
+     case ContextNode::IMAGE:
+      event = L"IMAGE";
+      break;
+     case ContextNode::IMAGE_LINK:
+      event = L"IMAGE_LINK";
+      break;
+     case ContextNode::SELECTION:
+      event = L"SELECTION";
+      break;
+     case ContextNode::EDITABLE:
+      event = L"EDITABLE";
+      break;
+     case ContextNode::MISPELLED_WORD:
+      event = L"MISPELLED_WORD";
+      break;
+     default:
+      event = L"UNKNOWN";
+      break;
+    }
+
+    LogParam(event, l);
+  }
+};
+
+template <>
+struct ParamTraits<ViewHostMsg_ImeControl> {
+  typedef ViewHostMsg_ImeControl param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type))
+      return false;
+    *p = static_cast<ViewHostMsg_ImeControl>(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring control;
+    switch(p) {
+     case IME_DISABLE:
+      control = L"IME_DISABLE";
+      break;
+     case IME_MOVE_WINDOWS:
+      control = L"IME_MOVE_WINDOWS";
+      break;
+     case IME_COMPLETE_COMPOSITION:
+      control = L"IME_COMPLETE_COMPOSITION";
+      break;
+     default:
+      control = L"UNKNOWN";
+      break;
+    }
+
+    LogParam(control, l);
+  }
+};
+
+// Traits for ViewMsg_Navigate_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewMsg_Navigate_Params> {
+  typedef ViewMsg_Navigate_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.page_id);
+    WriteParam(m, p.url);
+    WriteParam(m, p.transition);
+    WriteParam(m, p.state);
+    WriteParam(m, p.reload);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->page_id) &&
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->transition) &&
+      ReadParam(m, iter, &p->state) &&
+      ReadParam(m, iter, &p->reload);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.page_id, l);
+    l->append(L", ");
+    LogParam(p.url, l);
+    l->append(L", ");
+    LogParam(p.transition, l);
+    l->append(L", ");
+    LogParam(p.state, l);
+    l->append(L", ");
+    LogParam(p.reload, l);
+    l->append(L")");
+  }
+};
+
+// Traits for PasswordForm_Params structure to pack/unpack.
+template <>
+struct ParamTraits<PasswordForm> {
+  typedef PasswordForm param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.signon_realm);
+    WriteParam(m, p.origin);
+    WriteParam(m, p.action);
+    WriteParam(m, p.submit_element);
+    WriteParam(m, p.username_element);
+    WriteParam(m, p.username_value);
+    WriteParam(m, p.password_element);
+    WriteParam(m, p.password_value);
+    WriteParam(m, p.old_password_element);
+    WriteParam(m, p.old_password_value);
+    WriteParam(m, p.ssl_valid);
+    WriteParam(m, p.preferred);
+    WriteParam(m, p.blacklisted_by_user);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->signon_realm) &&
+      ReadParam(m, iter, &p->origin) &&
+      ReadParam(m, iter, &p->action) &&
+      ReadParam(m, iter, &p->submit_element) &&
+      ReadParam(m, iter, &p->username_element) &&
+      ReadParam(m, iter, &p->username_value) &&
+      ReadParam(m, iter, &p->password_element) &&
+      ReadParam(m, iter, &p->password_value) &&
+      ReadParam(m, iter, &p->old_password_element) &&
+      ReadParam(m, iter, &p->old_password_value) &&
+      ReadParam(m, iter, &p->ssl_valid) &&
+      ReadParam(m, iter, &p->preferred) &&
+      ReadParam(m, iter, &p->blacklisted_by_user);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<PasswordForm>");
+  }
+};
+
+// Traits for ViewHostMsg_FrameNavigate_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewHostMsg_FrameNavigate_Params> {
+  typedef ViewHostMsg_FrameNavigate_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.page_id);
+    WriteParam(m, p.url);
+    WriteParam(m, p.referrer);
+    WriteParam(m, p.transition);
+    WriteParam(m, p.redirects);
+    WriteParam(m, p.should_update_history);
+    WriteParam(m, p.searchable_form_url);
+    WriteParam(m, p.searchable_form_element_name);
+    WriteParam(m, p.searchable_form_encoding);
+    WriteParam(m, p.password_form);
+    WriteParam(m, p.security_info);
+    WriteParam(m, p.gesture);
+    WriteParam(m, p.contents_mime_type);
+    WriteParam(m, p.is_post);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->page_id) &&
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->referrer) &&
+      ReadParam(m, iter, &p->transition) &&
+      ReadParam(m, iter, &p->redirects) &&
+      ReadParam(m, iter, &p->should_update_history) &&
+      ReadParam(m, iter, &p->searchable_form_url) &&
+      ReadParam(m, iter, &p->searchable_form_element_name) &&
+      ReadParam(m, iter, &p->searchable_form_encoding) &&
+      ReadParam(m, iter, &p->password_form) &&
+      ReadParam(m, iter, &p->security_info) &&
+      ReadParam(m, iter, &p->gesture) &&
+      ReadParam(m, iter, &p->contents_mime_type) &&
+      ReadParam(m, iter, &p->is_post);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.page_id, l);
+    l->append(L", ");
+    LogParam(p.url, l);
+    l->append(L", ");
+    LogParam(p.referrer, l);
+    l->append(L", ");
+    LogParam(p.transition, l);
+    l->append(L", ");
+    LogParam(p.redirects, l);
+    l->append(L", ");
+    LogParam(p.should_update_history, l);
+    l->append(L", ");
+    LogParam(p.searchable_form_url, l);
+    l->append(L", ");
+    LogParam(p.searchable_form_element_name, l);
+    l->append(L", ");
+    LogParam(p.searchable_form_encoding, l);
+    l->append(L", ");
+    LogParam(p.password_form, l);
+    l->append(L", ");
+    LogParam(p.security_info, l);
+    l->append(L", ");
+    LogParam(p.gesture, l);
+    l->append(L", ");
+    LogParam(p.contents_mime_type, l);
+    l->append(L", ");
+    LogParam(p.is_post, l);
+    l->append(L")");
+  }
+};
+
+// Traits for ViewHostMsg_ContextMenu_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewHostMsg_ContextMenu_Params> {
+  typedef ViewHostMsg_ContextMenu_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.type);
+    WriteParam(m, p.x);
+    WriteParam(m, p.y);
+    WriteParam(m, p.link_url);
+    WriteParam(m, p.image_url);
+    WriteParam(m, p.page_url);
+    WriteParam(m, p.frame_url);
+    WriteParam(m, p.selection_text);
+    WriteParam(m, p.misspelled_word);
+    WriteParam(m, p.dictionary_suggestions);
+    WriteParam(m, p.edit_flags);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->type) &&
+      ReadParam(m, iter, &p->x) &&
+      ReadParam(m, iter, &p->y) &&
+      ReadParam(m, iter, &p->link_url) &&
+      ReadParam(m, iter, &p->image_url) &&
+      ReadParam(m, iter, &p->page_url) &&
+      ReadParam(m, iter, &p->frame_url) &&
+      ReadParam(m, iter, &p->selection_text) &&
+      ReadParam(m, iter, &p->misspelled_word) &&
+      ReadParam(m, iter, &p->dictionary_suggestions) &&
+      ReadParam(m, iter, &p->edit_flags);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewHostMsg_ContextMenu_Params>");
+  }
+};
+
+// Traits for ViewHostMsg_PaintRect_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewHostMsg_PaintRect_Params> {
+  typedef ViewHostMsg_PaintRect_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.bitmap);
+    WriteParam(m, p.bitmap_rect);
+    WriteParam(m, p.view_size);
+    WriteParam(m, p.plugin_window_moves);
+    WriteParam(m, p.flags);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->bitmap) &&
+      ReadParam(m, iter, &p->bitmap_rect) &&
+      ReadParam(m, iter, &p->view_size) &&
+      ReadParam(m, iter, &p->plugin_window_moves) &&
+      ReadParam(m, iter, &p->flags);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.bitmap, l);
+    l->append(L", ");
+    LogParam(p.bitmap_rect, l);
+    l->append(L", ");
+    LogParam(p.view_size, l);
+    l->append(L", ");
+    LogParam(p.plugin_window_moves, l);
+    l->append(L", ");
+    LogParam(p.flags, l);
+    l->append(L")");
+  }
+};
+
+// Traits for ViewHostMsg_ScrollRect_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewHostMsg_ScrollRect_Params> {
+  typedef ViewHostMsg_ScrollRect_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.bitmap);
+    WriteParam(m, p.bitmap_rect);
+    WriteParam(m, p.dx);
+    WriteParam(m, p.dy);
+    WriteParam(m, p.clip_rect);
+    WriteParam(m, p.view_size);
+    WriteParam(m, p.plugin_window_moves);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->bitmap) &&
+      ReadParam(m, iter, &p->bitmap_rect) &&
+      ReadParam(m, iter, &p->dx) &&
+      ReadParam(m, iter, &p->dy) &&
+      ReadParam(m, iter, &p->clip_rect) &&
+      ReadParam(m, iter, &p->view_size) &&
+      ReadParam(m, iter, &p->plugin_window_moves);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.bitmap, l);
+    l->append(L", ");
+    LogParam(p.bitmap_rect, l);
+    l->append(L", ");
+    LogParam(p.dx, l);
+    l->append(L", ");
+    LogParam(p.dy, l);
+    l->append(L", ");
+    LogParam(p.clip_rect, l);
+    l->append(L", ");
+    LogParam(p.view_size, l);
+    l->append(L", ");
+    LogParam(p.plugin_window_moves, l);
+    l->append(L")");
+  }
+};
+
+template <>
+struct ParamTraits<WebPluginGeometry> {
+  typedef WebPluginGeometry param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.window);
+    WriteParam(m, p.window_rect);
+    WriteParam(m, p.clip_rect);
+    WriteParam(m, p.visible);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->window) &&
+      ReadParam(m, iter, &p->window_rect) &&
+      ReadParam(m, iter, &p->clip_rect) &&
+      ReadParam(m, iter, &p->visible);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.window, l);
+    l->append(L", ");
+    LogParam(p.window_rect, l);
+    l->append(L", ");
+    LogParam(p.clip_rect, l);
+    l->append(L", ");
+    LogParam(p.visible, l);
+    l->append(L")");
+  }
+};
+
+// Traits for ViewMsg_GetPlugins_Reply structure to pack/unpack.
+template <>
+struct ParamTraits<WebPluginMimeType> {
+  typedef WebPluginMimeType param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.mime_type);
+    WriteParam(m, p.file_extensions);
+    WriteParam(m, p.description);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->mime_type) &&
+      ReadParam(m, iter, &r->file_extensions) &&
+      ReadParam(m, iter, &r->description);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.mime_type, l);
+    l->append(L", ");
+    LogParam(p.file_extensions, l);
+    l->append(L", ");
+    LogParam(p.description, l);
+    l->append(L")");
+  }
+};
+
+
+template <>
+struct ParamTraits<WebPluginInfo> {
+  typedef WebPluginInfo param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.name);
+    WriteParam(m, p.file);
+    WriteParam(m, p.version);
+    WriteParam(m, p.desc);
+    WriteParam(m, p.mime_types);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->name) &&
+      ReadParam(m, iter, &r->file) &&
+      ReadParam(m, iter, &r->version) &&
+      ReadParam(m, iter, &r->desc) &&
+      ReadParam(m, iter, &r->mime_types);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.name, l);
+    l->append(L", ");
+    LogParam(p.file, l);
+    l->append(L", ");
+    LogParam(p.version, l);
+    l->append(L", ");
+    LogParam(p.desc, l);
+    l->append(L", ");
+    LogParam(p.mime_types, l);
+    l->append(L")");
+  }
+};
+
+// Traits for ViewMsg_UploadFile_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewMsg_UploadFile_Params> {
+  typedef ViewMsg_UploadFile_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.file_path);
+    WriteParam(m, p.form);
+    WriteParam(m, p.file);
+    WriteParam(m, p.submit);
+    WriteParam(m, p.other_values);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->file_path) &&
+      ReadParam(m, iter, &p->form) &&
+      ReadParam(m, iter, &p->file) &&
+      ReadParam(m, iter, &p->submit) &&
+      ReadParam(m, iter, &p->other_values);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewMsg_UploadFile_Params>");
+  }
+};
+
+// Traits for ViewMsg_FindInPageMsg_Request structure to pack/unpack.
+template <>
+struct ParamTraits<FindInPageRequest> {
+  typedef FindInPageRequest param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.request_id);
+    WriteParam(m, p.search_string);
+    WriteParam(m, p.forward);
+    WriteParam(m, p.match_case);
+    WriteParam(m, p.find_next);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->request_id) &&
+      ReadParam(m, iter, &p->search_string) &&
+      ReadParam(m, iter, &p->forward) &&
+      ReadParam(m, iter, &p->match_case) &&
+      ReadParam(m, iter, &p->find_next);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<FindInPageRequest>");
+  }
+};
+
+// Traits for net::UploadData::Element.
+template <>
+struct ParamTraits<net::UploadData::Element> {
+  typedef net::UploadData::Element param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.type()));
+    if (p.type() == net::UploadData::TYPE_BYTES) {
+      m->WriteData(&p.bytes()[0], static_cast<int>(p.bytes().size()));
+    } else {
+      WriteParam(m, p.file_path());
+      WriteParam(m, p.file_range_offset());
+      WriteParam(m, p.file_range_length());
+    }
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int type;
+    if (!ReadParam(m, iter, &type))
+      return false;
+    if (type == net::UploadData::TYPE_BYTES) {
+      const char* data;
+      int len;
+      if (!m->ReadData(iter, &data, &len))
+        return false;
+      r->SetToBytes(data, len);
+    } else {
+      DCHECK(type == net::UploadData::TYPE_FILE);
+      std::wstring file_path;
+      uint64 offset, length;
+      if (!ReadParam(m, iter, &file_path))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      r->SetToFilePathRange(file_path, offset, length);
+    }
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<net::UploadData::Element>");
+  }
+};
+
+// Traits for CacheManager::UsageStats
+template <>
+struct ParamTraits<CacheManager::UsageStats> {
+  typedef CacheManager::UsageStats param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.min_dead_capacity);
+    WriteParam(m, p.max_dead_capacity);
+    WriteParam(m, p.capacity);
+    WriteParam(m, p.live_size);
+    WriteParam(m, p.dead_size);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->min_dead_capacity) &&
+      ReadParam(m, iter, &r->max_dead_capacity) &&
+      ReadParam(m, iter, &r->capacity) &&
+      ReadParam(m, iter, &r->live_size) &&
+      ReadParam(m, iter, &r->dead_size);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<CacheManager::UsageStats>");
+  }
+};
+
+// Traits for PasswordFormDomManager::FillData.
+template <>
+struct ParamTraits<PasswordFormDomManager::FillData> {
+  typedef PasswordFormDomManager::FillData param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.basic_data);
+    WriteParam(m, p.additional_logins);
+    WriteParam(m, p.wait_for_username);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->basic_data) &&
+      ReadParam(m, iter, &r->additional_logins) &&
+      ReadParam(m, iter, &r->wait_for_username);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<PasswordFormDomManager::FillData>");
+  }
+};
+
+template<>
+struct ParamTraits<NavigationGesture> {
+  typedef NavigationGesture param_type;
+  static void Write(Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    int type;
+    if (!m->ReadInt(iter, &type))
+      return false;
+    *p = static_cast<NavigationGesture>(type);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring event;
+    switch(p) {
+      case NavigationGestureUser:
+        event = L"GESTURE_USER";
+        break;
+      case NavigationGestureAuto:
+        event = L"GESTURE_AUTO";
+        break;
+      default:
+        event = L"GESTURE_UNKNOWN";
+        break;
+    }
+    LogParam(event, l);
+  }
+};
+
+// Traits for ViewHostMsg_Resource_Request
+template <>
+struct ParamTraits<ViewHostMsg_Resource_Request> {
+  typedef ViewHostMsg_Resource_Request param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.method);
+    WriteParam(m, p.url);
+    WriteParam(m, p.policy_url);
+    WriteParam(m, p.referrer);
+    WriteParam(m, p.headers);
+    WriteParam(m, p.load_flags);
+    WriteParam(m, p.origin_pid);
+    WriteParam(m, p.resource_type);
+    WriteParam(m, p.mixed_content);
+    WriteParam(m, p.request_context);
+    WriteParam(m, p.upload_content);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->method) &&
+      ReadParam(m, iter, &r->url) &&
+      ReadParam(m, iter, &r->policy_url) &&
+      ReadParam(m, iter, &r->referrer) &&
+      ReadParam(m, iter, &r->headers) &&
+      ReadParam(m, iter, &r->load_flags) &&
+      ReadParam(m, iter, &r->origin_pid) &&
+      ReadParam(m, iter, &r->resource_type) &&
+      ReadParam(m, iter, &r->mixed_content) &&
+      ReadParam(m, iter, &r->request_context) &&
+      ReadParam(m, iter, &r->upload_content);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.method, l);
+    l->append(L", ");
+    LogParam(p.url, l);
+    l->append(L", ");
+    LogParam(p.referrer, l);
+    l->append(L", ");
+    LogParam(p.load_flags, l);
+    l->append(L", ");
+    LogParam(p.origin_pid, l);
+    l->append(L", ");
+    LogParam(p.resource_type, l);
+    l->append(L", ");
+    LogParam(p.mixed_content, l);
+    l->append(L", ");
+    LogParam(p.request_context, l);
+    l->append(L")");
+  }
+};
+
+// Traits for URLRequestStatus
+template <>
+struct ParamTraits<URLRequestStatus> {
+  typedef URLRequestStatus param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, static_cast<int>(p.status()));
+    WriteParam(m, p.os_error());
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    int status, os_error;
+    if (!ReadParam(m, iter, &status) ||
+        !ReadParam(m, iter, &os_error))
+      return false;
+    r->set_status(static_cast<URLRequestStatus::Status>(status));
+    r->set_os_error(os_error);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring status;
+    switch(p.status()) {
+     case URLRequestStatus::SUCCESS:
+      status = L"SUCCESS";
+      break;
+     case URLRequestStatus::IO_PENDING:
+      status = L"IO_PENDING ";
+      break;
+     case URLRequestStatus::HANDLED_EXTERNALLY:
+      status = L"HANDLED_EXTERNALLY";
+      break;
+     case URLRequestStatus::CANCELED:
+      status = L"CANCELED";
+      break;
+     case URLRequestStatus::FAILED:
+      status = L"FAILED";
+      break;
+     default:
+      status = L"UNKNOWN";
+      break;
+    }
+    if (p.status() == URLRequestStatus::FAILED)
+      l->append(L"(");
+
+    LogParam(status, l);
+
+    if (p.status() == URLRequestStatus::FAILED) {
+      l->append(L", ");
+      LogParam(p.os_error(), l);
+      l->append(L")");
+    }
+  }
+};
+
+template <>
+struct ParamTraits<scoped_refptr<net::HttpResponseHeaders>> {
+  typedef scoped_refptr<net::HttpResponseHeaders> param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.get() != NULL);
+    if (p)
+      p->Persist(m, false);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    bool has_object;
+    if (!ReadParam(m, iter, &has_object))
+      return false;
+    if (has_object)
+      *r = new net::HttpResponseHeaders(*m, iter);
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<HttpResponseHeaders>");
+  }
+};
+
+// Traits for webkit_glue::ResourceLoaderBridge::ResponseInfo
+template <>
+struct ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo> {
+  typedef webkit_glue::ResourceLoaderBridge::ResponseInfo param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.request_time);
+    WriteParam(m, p.response_time);
+    WriteParam(m, p.headers);
+    WriteParam(m, p.mime_type);
+    WriteParam(m, p.charset);
+    WriteParam(m, p.security_info);
+    WriteParam(m, p.content_length);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ReadParam(m, iter, &r->request_time) &&
+      ReadParam(m, iter, &r->response_time) &&
+      ReadParam(m, iter, &r->headers) &&
+      ReadParam(m, iter, &r->mime_type) &&
+      ReadParam(m, iter, &r->charset) &&
+      ReadParam(m, iter, &r->security_info) &&
+      ReadParam(m, iter, &r->content_length);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.request_time, l);
+    l->append(L", ");
+    LogParam(p.response_time, l);
+    l->append(L", ");
+    LogParam(p.headers, l);
+    l->append(L", ");
+    LogParam(p.mime_type, l);
+    l->append(L", ");
+    LogParam(p.charset, l);
+    l->append(L", ");
+    LogParam(p.security_info, l);
+    l->append(L")");
+  }
+};
+
+// Traits for ViewMsg_Resource_ResponseHead
+template <>
+struct ParamTraits<ViewMsg_Resource_ResponseHead> {
+  typedef ViewMsg_Resource_ResponseHead param_type;
+  static void Write(Message* m, const param_type& p) {
+    ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo>::Write(m, p);
+    WriteParam(m, p.status);
+    WriteParam(m, p.filter_policy);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo>::Read(m, iter, r) &&
+      ReadParam(m, iter, &r->status) &&
+      ReadParam(m, iter, &r->filter_policy);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    // log more?
+    ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo>::Log(p, l);
+  }
+};
+
+// Traits for ViewHostMsg_Resource_SyncLoad_Response
+template <>
+struct ParamTraits<ViewHostMsg_SyncLoad_Result> {
+  typedef ViewHostMsg_SyncLoad_Result param_type;
+  static void Write(Message* m, const param_type& p) {
+    ParamTraits<ViewMsg_Resource_ResponseHead>::Write(m, p);
+    WriteParam(m, p.final_url);
+    WriteParam(m, p.data);
+  }
+  static bool Read(const Message* m, void** iter, param_type* r) {
+    return
+      ParamTraits<ViewMsg_Resource_ResponseHead>::Read(m, iter, r) &&
+      ReadParam(m, iter, &r->final_url) &&
+      ReadParam(m, iter, &r->data);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    // log more?
+    ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo>::Log(p, l);
+  }
+};
+
+// Traits for FormData structure to pack/unpack.
+template <>
+struct ParamTraits<FormData> {
+  typedef FormData param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.origin);
+    WriteParam(m, p.action);
+    WriteParam(m, p.elements);
+    WriteParam(m, p.values);
+    WriteParam(m, p.submit);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->origin) &&
+      ReadParam(m, iter, &p->action) &&
+      ReadParam(m, iter, &p->elements) &&
+      ReadParam(m, iter, &p->values) &&
+      ReadParam(m, iter, &p->submit);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<FormData>");
+  }
+};
+
+// Traits for ViewMsg_Print_Params
+template <>
+struct ParamTraits<ViewMsg_Print_Params> {
+  typedef ViewMsg_Print_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.printable_size);
+    WriteParam(m, p.dpi);
+    WriteParam(m, p.min_shrink);
+    WriteParam(m, p.max_shrink);
+    WriteParam(m, p.desired_dpi);
+    WriteParam(m, p.document_cookie);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return ReadParam(m, iter, &p->printable_size) &&
+           ReadParam(m, iter, &p->dpi) &&
+           ReadParam(m, iter, &p->min_shrink) &&
+           ReadParam(m, iter, &p->max_shrink) &&
+           ReadParam(m, iter, &p->desired_dpi) &&
+           ReadParam(m, iter, &p->document_cookie);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewMsg_Print_Params>");
+  }
+};
+
+// Traits for ViewMsg_PrintPage_Params
+template <>
+struct ParamTraits<ViewMsg_PrintPage_Params> {
+  typedef ViewMsg_PrintPage_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.params);
+    WriteParam(m, p.page_number);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return ReadParam(m, iter, &p->params) &&
+           ReadParam(m, iter, &p->page_number);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewMsg_PrintPage_Params>");
+  }
+};
+
+// Traits for ViewMsg_PrintPages_Params
+template <>
+struct ParamTraits<ViewMsg_PrintPages_Params> {
+  typedef ViewMsg_PrintPages_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.params);
+    WriteParam(m, p.pages);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return ReadParam(m, iter, &p->params) &&
+           ReadParam(m, iter, &p->pages);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewMsg_PrintPages_Params>");
+  }
+};
+
+// Traits for ViewHostMsg_DidPrintPage_Params
+template <>
+struct ParamTraits<ViewHostMsg_DidPrintPage_Params> {
+  typedef ViewHostMsg_DidPrintPage_Params param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.emf_data_handle);
+    WriteParam(m, p.data_size);
+    WriteParam(m, p.document_cookie);
+    WriteParam(m, p.page_number);
+    WriteParam(m, p.actual_shrink);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return ReadParam(m, iter, &p->emf_data_handle) &&
+           ReadParam(m, iter, &p->data_size) &&
+           ReadParam(m, iter, &p->document_cookie) &&
+           ReadParam(m, iter, &p->page_number) &&
+           ReadParam(m, iter, &p->actual_shrink);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewHostMsg_DidPrintPage_Params>");
+  }
+};
+
+// Traits for WebPreferences structure to pack/unpack.
+template <>
+struct ParamTraits<WebPreferences> {
+  typedef WebPreferences param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.standard_font_family);
+    WriteParam(m, p.fixed_font_family);
+    WriteParam(m, p.serif_font_family);
+    WriteParam(m, p.sans_serif_font_family);
+    WriteParam(m, p.cursive_font_family);
+    WriteParam(m, p.fantasy_font_family);
+    WriteParam(m, p.default_font_size);
+    WriteParam(m, p.default_fixed_font_size);
+    WriteParam(m, p.minimum_font_size);
+    WriteParam(m, p.minimum_logical_font_size);
+    WriteParam(m, p.default_encoding);
+    WriteParam(m, p.javascript_enabled);
+    WriteParam(m, p.javascript_can_open_windows_automatically);
+    WriteParam(m, p.loads_images_automatically);
+    WriteParam(m, p.plugins_enabled);
+    WriteParam(m, p.dom_paste_enabled);
+    WriteParam(m, p.developer_extras_enabled);
+    WriteParam(m, p.shrinks_standalone_images_to_fit);
+    WriteParam(m, p.uses_universal_detector);
+    WriteParam(m, p.text_areas_are_resizable);
+    WriteParam(m, p.dashboard_compatibility_mode);
+    WriteParam(m, p.java_enabled);
+    WriteParam(m, p.user_style_sheet_enabled);
+    WriteParam(m, p.user_style_sheet_location);
+    WriteParam(m, p.user_agent);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->standard_font_family) &&
+      ReadParam(m, iter, &p->fixed_font_family) &&
+      ReadParam(m, iter, &p->serif_font_family) &&
+      ReadParam(m, iter, &p->sans_serif_font_family) &&
+      ReadParam(m, iter, &p->cursive_font_family) &&
+      ReadParam(m, iter, &p->fantasy_font_family) &&
+      ReadParam(m, iter, &p->default_font_size) &&
+      ReadParam(m, iter, &p->default_fixed_font_size) &&
+      ReadParam(m, iter, &p->minimum_font_size) &&
+      ReadParam(m, iter, &p->minimum_logical_font_size) &&
+      ReadParam(m, iter, &p->default_encoding) &&
+      ReadParam(m, iter, &p->javascript_enabled) &&
+      ReadParam(m, iter, &p->javascript_can_open_windows_automatically) &&
+      ReadParam(m, iter, &p->loads_images_automatically) &&
+      ReadParam(m, iter, &p->plugins_enabled) &&
+      ReadParam(m, iter, &p->dom_paste_enabled) &&
+      ReadParam(m, iter, &p->developer_extras_enabled) &&
+      ReadParam(m, iter, &p->shrinks_standalone_images_to_fit) &&
+      ReadParam(m, iter, &p->uses_universal_detector) &&
+      ReadParam(m, iter, &p->text_areas_are_resizable) &&
+      ReadParam(m, iter, &p->dashboard_compatibility_mode) &&
+      ReadParam(m, iter, &p->java_enabled) &&
+      ReadParam(m, iter, &p->user_style_sheet_enabled) &&
+      ReadParam(m, iter, &p->user_style_sheet_location) &&
+      ReadParam(m, iter, &p->user_agent);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<WebPreferences>");
+  }
+};
+
+// Traits for WebDropData
+template <>
+struct ParamTraits<WebDropData> {
+  typedef WebDropData param_type;
+  static void Write(Message* m, const param_type& p) {
+    WriteParam(m, p.url);
+    WriteParam(m, p.url_title);
+    WriteParam(m, p.filenames);
+    WriteParam(m, p.plain_text);
+    WriteParam(m, p.cf_html);
+    WriteParam(m, p.text_html);
+    WriteParam(m, p.file_description_filename);
+    WriteParam(m, p.file_contents);
+  }
+  static bool Read(const Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->url_title) &&
+      ReadParam(m, iter, &p->filenames) &&
+      ReadParam(m, iter, &p->plain_text) &&
+      ReadParam(m, iter, &p->cf_html) &&
+      ReadParam(m, iter, &p->text_html) &&
+      ReadParam(m, iter, &p->file_description_filename) &&
+      ReadParam(m, iter, &p->file_contents);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<WebDropData>");
+  }
+};
+
+}  // namespace IPC
+
+#endif  // CHROME_COMMON_RENDER_MESSAGES_H__