Make it easier to create new IPC channel types (i.e. renderer/plugin). Inste...

chrome/common/render_messages.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_COMMON_RENDER_MESSAGES_H_
 #define CHROME_COMMON_RENDER_MESSAGES_H_
 
 #include <string>
 #include <vector>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/ref_counted.h"
 #include "base/shared_memory.h"
 #include "chrome/common/bitmap_wire_data.h"
 #include "chrome/common/filter_policy.h"
-#include "chrome/common/ipc_message.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "chrome/common/modal_dialog_event.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/autofill_form.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/screen_info.h"
 #include "webkit/glue/webdropdata.h"
+#include "webkit/glue/webinputevent.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webview_delegate.h"
 
 #if defined(OS_POSIX)
 #include "skia/include/SkBitmap.h"
 #endif
 
 // Parameters structure for ViewMsg_Navigate, which has too many data
 // parameters to be reasonably put in a predefined IPC message.
@@ skipping 15 matching lines @@
   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.
+// Traits for ViewMsg_Navigate_Params structure to pack/unpack.
+template <>
+struct ParamTraits<ViewMsg_Navigate_Params> {
+  typedef ViewMsg_Navigate_Params param_type;
+  static void Write(IPC::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.state);
+    WriteParam(m, p.reload);
+  }
+  static bool Read(const IPC::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->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")");
+  }
+};
+
+
 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.
   GURL url;
 
@@ skipping 33 matching lines @@
   std::string contents_mime_type;
 
   // True if this was a post request.
   bool is_post;
 
   // Whether the content of the frame was replaced with some alternate content
   // (this can happen if the resource was insecure).
   bool is_content_filtered;
 };
 
-// Parameters structure for ViewHostMsg_ContextMenu, which has too many data
-// parameters to be reasonably put in a predefined IPC message.
+template <>
+struct ParamTraits<ViewHostMsg_FrameNavigate_Params> {
+  typedef ViewHostMsg_FrameNavigate_Params param_type;
+  static void Write(IPC::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);
+    WriteParam(m, p.is_content_filtered);
+  }
+  static bool Read(const IPC::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) &&
+      ReadParam(m, iter, &p->is_content_filtered);
+  }
+  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", ");
+    LogParam(p.is_content_filtered, l);
+    l->append(L")");
+  }
+};
+
+
 // 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 node;
 
   // These values represent the coordinates of the mouse when the context menu
@@ skipping 33 matching lines @@
   bool spellcheck_enabled;
 
   // These flags indicate to the browser whether the renderer believes it is
   // able to perform the corresponding action.
   int edit_flags;
 
   // The security info for the resource we are showing the menu on.
   std::string security_info;
 };
 
+template <>
+struct ParamTraits<ViewHostMsg_ContextMenu_Params> {
+  typedef ViewHostMsg_ContextMenu_Params param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    WriteParam(m, p.node);
+    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.spellcheck_enabled);
+    WriteParam(m, p.edit_flags);
+    WriteParam(m, p.security_info);
+  }
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->node) &&
+      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->spellcheck_enabled) &&
+      ReadParam(m, iter, &p->edit_flags) &&
+      ReadParam(m, iter, &p->security_info);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"<ViewHostMsg_ContextMenu_Params>");
+  }
+};
+
 // 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,
     IS_REPAINT_ACK = 1 << 2,
   };
   static bool is_resize_ack(int flags) {
     return (flags & IS_RESIZE_ACK) != 0;
@@ skipping 31 matching lines @@
   //   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.
+template <>
+struct ParamTraits<ViewHostMsg_PaintRect_Params> {
+  typedef ViewHostMsg_PaintRect_Params param_type;
+  static void Write(IPC::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 IPC::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")");
+  }
+};
+
+
 struct ViewHostMsg_ScrollRect_Params {
   // The bitmap to be painted into the rect exposed by scrolling.
   BitmapWireData 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.
+template <>
+struct ParamTraits<ViewHostMsg_ScrollRect_Params> {
+  typedef ViewHostMsg_ScrollRect_Params param_type;
+  static void Write(IPC::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 IPC::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")");
+  }
+};
+
+
 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.
+template <>
+struct ParamTraits<ViewMsg_UploadFile_Params> {
+  typedef ViewMsg_UploadFile_Params param_type;
+  static void Write(IPC::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 IPC::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>");
+  }
+};
+
+
 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
@@ skipping 21 matching lines @@
   // 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.
+template <>
+struct ParamTraits<ViewHostMsg_Resource_Request> {
+  typedef ViewHostMsg_Resource_Request param_type;
+  static void Write(IPC::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 IPC::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")");
+  }
+};
+
+
 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.
+template <>
+struct ParamTraits<webkit_glue::ResourceLoaderBridge::ResponseInfo> {
+  typedef webkit_glue::ResourceLoaderBridge::ResponseInfo param_type;
+  static void Write(IPC::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 IPC::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")");
+  }
+};
+
+template <>
+struct ParamTraits<ViewMsg_Resource_ResponseHead> {
+  typedef ViewMsg_Resource_ResponseHead param_type;
+  static void Write(IPC::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 IPC::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);
+  }
+};
+
+
 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.
+template <>
+struct ParamTraits<ViewHostMsg_SyncLoad_Result> {
+  typedef ViewHostMsg_SyncLoad_Result param_type;
+  static void Write(IPC::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 IPC::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);
+  }
+};
+
+
 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;
   }
 };
 
+template <>
+struct ParamTraits<ViewMsg_Print_Params> {
+  typedef ViewMsg_Print_Params param_type;
+  static void Write(IPC::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 IPC::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>");
+  }
+};
+
+
 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;
 };
 
+template <>
+struct ParamTraits<ViewMsg_PrintPage_Params> {
+  typedef ViewMsg_PrintPage_Params param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    WriteParam(m, p.params);
+    WriteParam(m, p.page_number);
+  }
+  static bool Read(const IPC::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>");
+  }
+};
+
+
 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;
 };
 
+template <>
+struct ParamTraits<ViewMsg_PrintPages_Params> {
+  typedef ViewMsg_PrintPages_Params param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    WriteParam(m, p.params);
+    WriteParam(m, p.pages);
+  }
+  static bool Read(const IPC::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>");
+  }
+};
+
+
 // 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.
   base::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;
 };
 
+template <>
+struct ParamTraits<ViewHostMsg_DidPrintPage_Params> {
+  typedef ViewHostMsg_DidPrintPage_Params param_type;
+  static void Write(IPC::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 IPC::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>");
+  }
+};
+
+
 // Parameters structure to hold a union of the possible IAccessible function
 // INPUT variables, with the unused fields always set to default value. Used in
 // ViewMsg_GetAccessibilityInfo, as only parameter.
 struct ViewMsg_Accessibility_In_Params {
   // Identifier to uniquely distinguish which instance of IAccessible is being
   // called upon on the renderer side.
   int iaccessible_id;
 
   // Identifier to resolve which IAccessible interface function is being called.
   int iaccessible_function_id;
 
   // Function input parameters.
   // Input VARIANT structure's LONG field to specify requested object.
   long input_variant_lval;
 
   // LONG input parameters, used differently depending on the function called.
   long input_long1;
   long input_long2;
 };
 
+template <>
+struct ParamTraits<ViewMsg_Accessibility_In_Params> {
+  typedef ViewMsg_Accessibility_In_Params param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    WriteParam(m, p.iaccessible_id);
+    WriteParam(m, p.iaccessible_function_id);
+    WriteParam(m, p.input_variant_lval);
+    WriteParam(m, p.input_long1);
+    WriteParam(m, p.input_long2);
+  }
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->iaccessible_id) &&
+      ReadParam(m, iter, &p->iaccessible_function_id) &&
+      ReadParam(m, iter, &p->input_variant_lval) &&
+      ReadParam(m, iter, &p->input_long1) &&
+      ReadParam(m, iter, &p->input_long2);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.iaccessible_id, l);
+    l->append(L", ");
+    LogParam(p.iaccessible_function_id, l);
+    l->append(L", ");
+    LogParam(p.input_variant_lval, l);
+    l->append(L", ");
+    LogParam(p.input_long1, l);
+    l->append(L", ");
+    LogParam(p.input_long2, l);
+    l->append(L")");
+  }
+};
+
+
 // Parameters structure to hold a union of the possible IAccessible function
 // OUTPUT variables, with the unused fields always set to default value. Used in
 // ViewHostMsg_GetAccessibilityInfoResponse, as only parameter.
 struct ViewHostMsg_Accessibility_Out_Params {
   // Identifier to uniquely distinguish which instance of IAccessible is being
   // called upon on the renderer side.
   int iaccessible_id;
 
   // Function output parameters.
   // Output VARIANT structure's LONG field to specify requested object.
   long output_variant_lval;
 
   // LONG output parameters, used differently depending on the function called.
   // output_long1 can in some cases be set to -1 to indicate that the child
   // object found by the called IAccessible function is not a simple object.
   long output_long1;
   long output_long2;
   long output_long3;
   long output_long4;
 
   // String output parameter.
   std::wstring output_string;
 
   // Return code, either S_OK (true) or S_FALSE (false). WebKit MSAA error
   // return codes (E_POINTER, E_INVALIDARG, E_FAIL, E_NOTIMPL) must be handled
   // on the browser side by input validation.
   bool return_code;
 };
 
+template <>
+struct ParamTraits<ViewHostMsg_Accessibility_Out_Params> {
+  typedef ViewHostMsg_Accessibility_Out_Params param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    WriteParam(m, p.iaccessible_id);
+    WriteParam(m, p.output_variant_lval);
+    WriteParam(m, p.output_long1);
+    WriteParam(m, p.output_long2);
+    WriteParam(m, p.output_long3);
+    WriteParam(m, p.output_long4);
+    WriteParam(m, p.output_string);
+    WriteParam(m, p.return_code);
+  }
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
+    return
+      ReadParam(m, iter, &p->iaccessible_id) &&
+      ReadParam(m, iter, &p->output_variant_lval) &&
+      ReadParam(m, iter, &p->output_long1) &&
+      ReadParam(m, iter, &p->output_long2) &&
+      ReadParam(m, iter, &p->output_long3) &&
+      ReadParam(m, iter, &p->output_long4) &&
+      ReadParam(m, iter, &p->output_string) &&
+      ReadParam(m, iter, &p->return_code);
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    l->append(L"(");
+    LogParam(p.iaccessible_id, l);
+    l->append(L", ");
+    LogParam(p.output_variant_lval, l);
+    l->append(L", ");
+    LogParam(p.output_long1, l);
+    l->append(L", ");
+    LogParam(p.output_long2, l);
+    l->append(L", ");
+    LogParam(p.output_long3, l);
+    l->append(L", ");
+    LogParam(p.output_long4, l);
+    l->append(L", ");
+    LogParam(p.output_string, l);
+    l->append(L", ");
+    LogParam(p.return_code, l);
+    l->append(L")");
+  }
+};
+
+
 // 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"
+template <>
+struct ParamTraits<ViewHostMsg_ImeControl> {
+  typedef ViewHostMsg_ImeControl param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    m->WriteInt(p);
+  }
+  static bool Read(const IPC::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;
+    }
 
-#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
+    LogParam(control, l);
+  }
+};
 
 
-namespace IPC {
-
+// These traits are for structures that are defined outside of this file.
 template <>
 struct ParamTraits<ResourceType::Type> {
   typedef ResourceType::Type param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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:
@@ skipping 13 matching lines @@
        break;
     }
 
     LogParam(type, l);
   }
 };
 
 template <>
 struct ParamTraits<FilterPolicy::Type> {
   typedef FilterPolicy::Type param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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:
@@ skipping 10 matching lines @@
         break;
     }
 
     LogParam(type, l);
   }
 };
 
 template <>
 struct ParamTraits<ContextNode> {
   typedef ContextNode param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     m->WriteInt(p.type);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     int type;
     if (!m->ReadInt(iter, &type))
       return false;
     *p = ContextNode(type);
     return true;
   }
   static void Log(const param_type& p, std::wstring* l) {
     std::wstring event = L"";
 
     if (!p.type) {
@@ skipping 17 matching lines @@
       event.append(L")");
     }
 
     LogParam(event, l);
   }
 };
 
 template <>
 struct ParamTraits<WebInputEvent::Type> {
   typedef WebInputEvent::Type param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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 type;
     switch (p) {
      case WebInputEvent::MOUSE_DOWN:
@@ skipping 22 matching lines @@
       break;
      default:
       type = L"UNKNOWN";
       break;
     }
 
     LogParam(type, l);
   }
 };
 
-// Traits for ViewMsg_Accessibility_In_Params structure to pack/unpack.
-template <>
-struct ParamTraits<ViewMsg_Accessibility_In_Params> {
-  typedef ViewMsg_Accessibility_In_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.iaccessible_id);
-    WriteParam(m, p.iaccessible_function_id);
-    WriteParam(m, p.input_variant_lval);
-    WriteParam(m, p.input_long1);
-    WriteParam(m, p.input_long2);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->iaccessible_id) &&
-      ReadParam(m, iter, &p->iaccessible_function_id) &&
-      ReadParam(m, iter, &p->input_variant_lval) &&
-      ReadParam(m, iter, &p->input_long1) &&
-      ReadParam(m, iter, &p->input_long2);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"(");
-    LogParam(p.iaccessible_id, l);
-    l->append(L", ");
-    LogParam(p.iaccessible_function_id, l);
-    l->append(L", ");
-    LogParam(p.input_variant_lval, l);
-    l->append(L", ");
-    LogParam(p.input_long1, l);
-    l->append(L", ");
-    LogParam(p.input_long2, l);
-    l->append(L")");
-  }
-};
-
-// Traits for ViewHostMsg_Accessibility_Out_Params structure to pack/unpack.
-template <>
-struct ParamTraits<ViewHostMsg_Accessibility_Out_Params> {
-  typedef ViewHostMsg_Accessibility_Out_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.iaccessible_id);
-    WriteParam(m, p.output_variant_lval);
-    WriteParam(m, p.output_long1);
-    WriteParam(m, p.output_long2);
-    WriteParam(m, p.output_long3);
-    WriteParam(m, p.output_long4);
-    WriteParam(m, p.output_string);
-    WriteParam(m, p.return_code);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->iaccessible_id) &&
-      ReadParam(m, iter, &p->output_variant_lval) &&
-      ReadParam(m, iter, &p->output_long1) &&
-      ReadParam(m, iter, &p->output_long2) &&
-      ReadParam(m, iter, &p->output_long3) &&
-      ReadParam(m, iter, &p->output_long4) &&
-      ReadParam(m, iter, &p->output_string) &&
-      ReadParam(m, iter, &p->return_code);
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    l->append(L"(");
-    LogParam(p.iaccessible_id, l);
-    l->append(L", ");
-    LogParam(p.output_variant_lval, l);
-    l->append(L", ");
-    LogParam(p.output_long1, l);
-    l->append(L", ");
-    LogParam(p.output_long2, l);
-    l->append(L", ");
-    LogParam(p.output_long3, l);
-    l->append(L", ");
-    LogParam(p.output_long4, l);
-    l->append(L", ");
-    LogParam(p.output_string, l);
-    l->append(L", ");
-    LogParam(p.return_code, l);
-    l->append(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.referrer);
-    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->referrer) &&
-      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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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 AutofillForm_Params structure to pack/unpack.
 template <>
 struct ParamTraits<AutofillForm> {
   typedef AutofillForm param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.elements.size());
     for (std::vector<AutofillForm::Element>::const_iterator itr =
         p.elements.begin();
         itr != p.elements.end();
         itr++) {
       WriteParam(m, itr->name);
       WriteParam(m, itr->value);
     }
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
       bool result = true;
       size_t elements_size = 0;
       result = result && ReadParam(m, iter, &elements_size);
       p->elements.resize(elements_size);
       for (size_t i = 0; i < elements_size; i++) {
         std::wstring s;
         result = result && ReadParam(m, iter, &(p->elements[i].name));
         result = result && ReadParam(m, iter, &(p->elements[i].value));
       }
       return result;
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<AutofillForm>");
   }
 };
 
-// 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);
-    WriteParam(m, p.is_content_filtered);
-  }
-  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) &&
-      ReadParam(m, iter, &p->is_content_filtered);
-  }
-  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", ");
-    LogParam(p.is_content_filtered, 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.node);
-    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.spellcheck_enabled);
-    WriteParam(m, p.edit_flags);
-    WriteParam(m, p.security_info);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->node) &&
-      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->spellcheck_enabled) &&
-      ReadParam(m, iter, &p->edit_flags) &&
-      ReadParam(m, iter, &p->security_info);
-  }
-  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) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.window);
     WriteParam(m, p.window_rect);
     WriteParam(m, p.clip_rect);
     WriteParam(m, p.cutout_rects);
     WriteParam(m, p.visible);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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->cutout_rects) &&
       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.cutout_rects, 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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.name);
     WriteParam(m, p.path);
     WriteParam(m, p.version);
     WriteParam(m, p.desc);
     WriteParam(m, p.mime_types);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* r) {
     return
       ReadParam(m, iter, &r->name) &&
       ReadParam(m, iter, &r->path) &&
       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", ");
     l->append(L", ");
     LogParam(p.path, 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 net::UploadData::Element.
 template <>
 struct ParamTraits<net::UploadData::Element> {
   typedef net::UploadData::Element param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::Message* m, const param_type& p) {
     m->WriteInt(p);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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;
@@ skipping 26 matching lines @@
       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) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.get() != NULL);
     if (p) {
       // Do not disclose Set-Cookie headers over IPC.
       p->Persist(m, net::HttpResponseHeaders::PERSIST_SANS_COOKIES);
     }
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::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) {
+  static bool Read(const IPC::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) {
+  static void Write(IPC::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.java_enabled);
     WriteParam(m, p.user_style_sheet_enabled);
     WriteParam(m, p.user_style_sheet_location);
     WriteParam(m, p.uses_page_cache);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::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) &&
@@ skipping 11 matching lines @@
         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->uses_page_cache);
   }
   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) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.url);
     WriteParam(m, p.url_title);
     WriteParam(m, p.file_extension);
     WriteParam(m, p.filenames);
     WriteParam(m, p.plain_text);
     WriteParam(m, p.text_html);
     WriteParam(m, p.html_base_url);
     WriteParam(m, p.file_description_filename);
     WriteParam(m, p.file_contents);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     return
       ReadParam(m, iter, &p->url) &&
       ReadParam(m, iter, &p->url_title) &&
       ReadParam(m, iter, &p->file_extension) &&
       ReadParam(m, iter, &p->filenames) &&
       ReadParam(m, iter, &p->plain_text) &&
       ReadParam(m, iter, &p->text_html) &&
       ReadParam(m, iter, &p->html_base_url) &&
       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>");
   }
 };
 
-// Traits for ScreenInfo
 template <>
 struct ParamTraits<webkit_glue::ScreenInfo> {
   typedef webkit_glue::ScreenInfo param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.depth);
     WriteParam(m, p.depth_per_component);
     WriteParam(m, p.is_monochrome);
     WriteParam(m, p.rect);
     WriteParam(m, p.available_rect);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     return
       ReadParam(m, iter, &p->depth) &&
       ReadParam(m, iter, &p->depth_per_component) &&
       ReadParam(m, iter, &p->is_monochrome) &&
       ReadParam(m, iter, &p->rect) &&
       ReadParam(m, iter, &p->available_rect);
   }
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<webkit_glue::ScreenInfo>");
   }
 };
 
 template<>
 struct ParamTraits<ModalDialogEvent> {
   typedef ModalDialogEvent param_type;
 #if defined(OS_WIN)
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.event);
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     return ReadParam(m, iter, &p->event);
   }
 #else
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
   }
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     return true;
   }
 #endif
 
   static void Log(const param_type& p, std::wstring* l) {
     l->append(L"<ModalDialogEvent>");
   }
 };
 
 #if defined(OS_POSIX)
 
 // TODO(port): this shouldn't exist. However, the plugin stuff is really using
 // HWNDS (NativeView), and making Windows calls based on them. I've not figured
 // out the deal with plugins yet.
 template <>
 struct ParamTraits<gfx::NativeView> {
   typedef gfx::NativeView param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     NOTIMPLEMENTED();
   }
 
-  static bool Read(const Message* m, void** iter, param_type* p) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* p) {
     NOTIMPLEMENTED();
     *p = NULL;
     return true;
   }
 
   static void Log(const param_type& p, std::wstring* l) {
     l->append(StringPrintf(L"<gfx::NativeView>"));
   }
 };
 
 #endif  // defined(OS_POSIX)
 
-}  // namespace IPC
+
+#define MESSAGES_INTERNAL_FILE "chrome/common/render_messages_internal.h"
+#include "chrome/common/ipc_message_macros.h"
 
 #endif  // CHROME_COMMON_RENDER_MESSAGES_H_