FBTF: Add default ctors/dtors for various param structs.

This patch also moves ParamTraits method definitions to the cc file.

(hbono@ has a patch out that does this for render_messages_params.h, so this
patch doesn't touch that to make sure we don't conflict.)

BUG=none
TEST=compiles

Review URL: http://codereview.chromium.org/3413003

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

7 files changed, 457 insertions, 272 deletions

diff --git a/chrome/browser/chrome_plugin_host.cc b/chrome/browser/chrome_plugin_host.cc
index 806d5da..0789957 100644
--- a/chrome/browser/chrome_plugin_host.cc
+++ b/chrome/browser/chrome_plugin_host.cc
@@ -16,6 +16,7 @@
 #include "base/perftimer.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chrome_plugin_browsing_context.h"
 #include "chrome/browser/chrome_thread.h"
diff --git a/chrome/browser/plugin_process_host.cc b/chrome/browser/plugin_process_host.cc
index 601fa60..8d99eab 100644
--- a/chrome/browser/plugin_process_host.cc
+++ b/chrome/browser/plugin_process_host.cc
@@ -19,6 +19,7 @@
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/chrome_plugin_browsing_context.h"
 #include "chrome/browser/chrome_thread.h"
diff --git a/chrome/common/plugin_messages.cc b/chrome/common/plugin_messages.cc
index 3079dcc..cbe72fa 100644
--- a/chrome/common/plugin_messages.cc
+++ b/chrome/common/plugin_messages.cc
@@ -1,11 +1,308 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+ // Copyright (c) 2010 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.
 
 #include "chrome/common/plugin_messages.h"
 
+#include "base/utf_string_conversions.h"
 #include "ipc/ipc_channel_handle.h"
 
 #define MESSAGES_INTERNAL_IMPL_FILE \
   "chrome/common/plugin_messages_internal.h"
 #include "ipc/ipc_message_impl_macros.h"
+
+PluginMsg_Init_Params::PluginMsg_Init_Params()
+    : load_manually(false),
+      host_render_view_routing_id(-1) {
+}
+
+PluginMsg_Init_Params::~PluginMsg_Init_Params() {
+}
+
+PluginHostMsg_URLRequest_Params::PluginHostMsg_URLRequest_Params()
+    : notify_id(-1),
+      popups_allowed(false) {
+}
+
+PluginHostMsg_URLRequest_Params::~PluginHostMsg_URLRequest_Params() {
+}
+
+PluginMsg_DidReceiveResponseParams::PluginMsg_DidReceiveResponseParams()
+    : id(-1),
+      expected_length(0),
+      last_modified(0),
+      request_is_seekable(false) {
+}
+
+PluginMsg_DidReceiveResponseParams::~PluginMsg_DidReceiveResponseParams() {
+}
+
+NPIdentifier_Param::NPIdentifier_Param()
+    : identifier() {
+}
+
+NPIdentifier_Param::~NPIdentifier_Param() {
+}
+
+NPVariant_Param::NPVariant_Param()
+    : type(NPVARIANT_PARAM_VOID),
+      bool_value(false),
+      int_value(0),
+      double_value(0),
+      npobject_routing_id(-1) {
+}
+
+NPVariant_Param::~NPVariant_Param() {
+}
+
+PluginMsg_UpdateGeometry_Param::PluginMsg_UpdateGeometry_Param()
+    : transparent(false)
+#if defined(OS_MACOSX)
+    , ack_key(-1)
+#endif
+{
+}
+
+PluginMsg_UpdateGeometry_Param::~PluginMsg_UpdateGeometry_Param() {
+}
+
+namespace IPC {
+
+void ParamTraits<PluginMsg_Init_Params>::Write(Message* m,
+                                               const param_type& p) {
+  WriteParam(m, p.containing_window);
+  WriteParam(m, p.url);
+  WriteParam(m, p.page_url);
+  DCHECK(p.arg_names.size() == p.arg_values.size());
+  WriteParam(m, p.arg_names);
+  WriteParam(m, p.arg_values);
+  WriteParam(m, p.load_manually);
+  WriteParam(m, p.host_render_view_routing_id);
+}
+
+bool ParamTraits<PluginMsg_Init_Params>::Read(const Message* m,
+                                              void** iter,
+                                              param_type* p) {
+  return ReadParam(m, iter, &p->containing_window) &&
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->page_url) &&
+      ReadParam(m, iter, &p->arg_names) &&
+      ReadParam(m, iter, &p->arg_values) &&
+      ReadParam(m, iter, &p->load_manually) &&
+      ReadParam(m, iter, &p->host_render_view_routing_id);
+}
+
+void ParamTraits<PluginMsg_Init_Params>::Log(const param_type& p,
+                                             std::string* l) {
+  l->append("(");
+  LogParam(p.containing_window, l);
+  l->append(", ");
+  LogParam(p.url, l);
+  l->append(", ");
+  LogParam(p.page_url, l);
+  l->append(", ");
+  LogParam(p.arg_names, l);
+  l->append(", ");
+  LogParam(p.arg_values, l);
+  l->append(", ");
+  LogParam(p.load_manually, l);
+  l->append(", ");
+  LogParam(p.host_render_view_routing_id, l);
+  l->append(")");
+}
+
+void ParamTraits<PluginHostMsg_URLRequest_Params>::Write(Message* m,
+                                                         const param_type& p) {
+  WriteParam(m, p.url);
+  WriteParam(m, p.method);
+  WriteParam(m, p.target);
+  WriteParam(m, p.buffer);
+  WriteParam(m, p.notify_id);
+  WriteParam(m, p.popups_allowed);
+}
+
+bool ParamTraits<PluginHostMsg_URLRequest_Params>::Read(const Message* m,
+                                                        void** iter,
+                                                        param_type* p) {
+  return
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->method) &&
+      ReadParam(m, iter, &p->target) &&
+      ReadParam(m, iter, &p->buffer) &&
+      ReadParam(m, iter, &p->notify_id) &&
+      ReadParam(m, iter, &p->popups_allowed);
+}
+
+void ParamTraits<PluginHostMsg_URLRequest_Params>::Log(const param_type& p,
+                                                       std::string* l) {
+  l->append("(");
+  LogParam(p.url, l);
+  l->append(", ");
+  LogParam(p.method, l);
+  l->append(", ");
+  LogParam(p.target, l);
+  l->append(", ");
+  LogParam(p.buffer, l);
+  l->append(", ");
+  LogParam(p.notify_id, l);
+  l->append(", ");
+  LogParam(p.popups_allowed, l);
+  l->append(")");
+}
+
+
+void ParamTraits<PluginMsg_DidReceiveResponseParams>::Write(
+    Message* m,
+    const param_type& p) {
+  WriteParam(m, p.id);
+  WriteParam(m, p.mime_type);
+  WriteParam(m, p.headers);
+  WriteParam(m, p.expected_length);
+  WriteParam(m, p.last_modified);
+  WriteParam(m, p.request_is_seekable);
+}
+
+bool ParamTraits<PluginMsg_DidReceiveResponseParams>::Read(const Message* m,
+                                                           void** iter,
+                                                           param_type* r) {
+  return
+      ReadParam(m, iter, &r->id) &&
+      ReadParam(m, iter, &r->mime_type) &&
+      ReadParam(m, iter, &r->headers) &&
+      ReadParam(m, iter, &r->expected_length) &&
+      ReadParam(m, iter, &r->last_modified) &&
+      ReadParam(m, iter, &r->request_is_seekable);
+}
+
+void ParamTraits<PluginMsg_DidReceiveResponseParams>::Log(const param_type& p,
+                                                          std::string* l) {
+  l->append("(");
+  LogParam(p.id, l);
+  l->append(", ");
+  LogParam(p.mime_type, l);
+  l->append(", ");
+  LogParam(p.headers, l);
+  l->append(", ");
+  LogParam(p.expected_length, l);
+  l->append(", ");
+  LogParam(p.last_modified, l);
+  l->append(", ");
+  LogParam(p.request_is_seekable, l);
+  l->append(")");
+}
+
+
+void ParamTraits<NPVariant_Param>::Write(Message* m, const param_type& p) {
+  WriteParam(m, static_cast<int>(p.type));
+  if (p.type == NPVARIANT_PARAM_BOOL) {
+    WriteParam(m, p.bool_value);
+  } else if (p.type == NPVARIANT_PARAM_INT) {
+    WriteParam(m, p.int_value);
+  } else if (p.type == NPVARIANT_PARAM_DOUBLE) {
+    WriteParam(m, p.double_value);
+  } else if (p.type == NPVARIANT_PARAM_STRING) {
+    WriteParam(m, p.string_value);
+  } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
+             p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
+    // This is the routing id used to connect NPObjectProxy in the other
+    // process with NPObjectStub in this process or to identify the raw
+    // npobject pointer to be used in the callee process.
+    WriteParam(m, p.npobject_routing_id);
+  } else {
+    DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL);
+  }
+}
+
+bool ParamTraits<NPVariant_Param>::Read(const Message* m,
+                                        void** iter,
+                                        param_type* r) {
+  int type;
+  if (!ReadParam(m, iter, &type))
+    return false;
+
+  bool result = false;
+  r->type = static_cast<NPVariant_ParamEnum>(type);
+  if (r->type == NPVARIANT_PARAM_BOOL) {
+    result = ReadParam(m, iter, &r->bool_value);
+  } else if (r->type == NPVARIANT_PARAM_INT) {
+    result = ReadParam(m, iter, &r->int_value);
+  } else if (r->type == NPVARIANT_PARAM_DOUBLE) {
+    result = ReadParam(m, iter, &r->double_value);
+  } else if (r->type == NPVARIANT_PARAM_STRING) {
+    result = ReadParam(m, iter, &r->string_value);
+  } else if (r->type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
+             r->type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
+    result = ReadParam(m, iter, &r->npobject_routing_id);
+  } else if ((r->type == NPVARIANT_PARAM_VOID) ||
+             (r->type == NPVARIANT_PARAM_NULL)) {
+    result = true;
+  } else {
+    NOTREACHED();
+  }
+
+  return result;
+}
+
+void ParamTraits<NPVariant_Param>::Log(const param_type& p, std::string* l) {
+  if (p.type == NPVARIANT_PARAM_BOOL) {
+    LogParam(p.bool_value, l);
+  } else if (p.type == NPVARIANT_PARAM_INT) {
+    LogParam(p.int_value, l);
+  } else if (p.type == NPVARIANT_PARAM_DOUBLE) {
+    LogParam(p.double_value, l);
+  } else if (p.type == NPVARIANT_PARAM_STRING) {
+    LogParam(p.string_value, l);
+  } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
+             p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
+    LogParam(p.npobject_routing_id, l);
+  }
+}
+
+void ParamTraits<PluginMsg_UpdateGeometry_Param>::Write(Message* m,
+                                                        const param_type& p) {
+  WriteParam(m, p.window_rect);
+  WriteParam(m, p.clip_rect);
+  WriteParam(m, p.windowless_buffer);
+  WriteParam(m, p.background_buffer);
+  WriteParam(m, p.transparent);
+#if defined(OS_MACOSX)
+  WriteParam(m, p.ack_key);
+#endif
+}
+
+bool ParamTraits<PluginMsg_UpdateGeometry_Param>::Read(const Message* m,
+                                                       void** iter,
+                                                       param_type* r) {
+  return
+      ReadParam(m, iter, &r->window_rect) &&
+      ReadParam(m, iter, &r->clip_rect) &&
+      ReadParam(m, iter, &r->windowless_buffer) &&
+      ReadParam(m, iter, &r->background_buffer) &&
+      ReadParam(m, iter, &r->transparent)
+#if defined(OS_MACOSX)
+      &&
+      ReadParam(m, iter, &r->ack_key)
+#endif
+      ;
+}
+
+void ParamTraits<PluginMsg_UpdateGeometry_Param>::Log(const param_type& p,
+                                                      std::string* l) {
+  l->append("(");
+  LogParam(p.window_rect, l);
+  l->append(", ");
+  LogParam(p.clip_rect, l);
+  l->append(", ");
+  LogParam(p.windowless_buffer, l);
+  l->append(", ");
+  LogParam(p.background_buffer, l);
+  l->append(", ");
+  LogParam(p.transparent, l);
+#if defined(OS_MACOSX)
+  l->append(", ");
+  LogParam(p.ack_key, l);
+#endif
+  l->append(")");
+}
+
+}  // namespace IPC
diff --git a/chrome/common/plugin_messages.h b/chrome/common/plugin_messages.h
index 56eaf50..638462f 100644
--- a/chrome/common/plugin_messages.h
+++ b/chrome/common/plugin_messages.h
@@ -16,7 +16,6 @@
 
 #include "base/basictypes.h"
 #include "base/string_number_conversions.h"
-#include "base/utf_string_conversions.h"
 #include "chrome/common/common_param_traits.h"
 #include "chrome/common/webkit_param_traits.h"
 #include "gfx/native_widget_types.h"
@@ -35,6 +34,9 @@
 // predefined IPC message.
 
 struct PluginMsg_Init_Params {
+  PluginMsg_Init_Params();
+  ~PluginMsg_Init_Params();
+
   gfx::NativeViewId containing_window;
   GURL url;
   GURL page_url;
@@ -45,6 +47,9 @@ struct PluginMsg_Init_Params {
 };
 
 struct PluginHostMsg_URLRequest_Params {
+  PluginHostMsg_URLRequest_Params();
+  ~PluginHostMsg_URLRequest_Params();
+
   std::string url;
   std::string method;
   std::string target;
@@ -54,6 +59,9 @@ struct PluginHostMsg_URLRequest_Params {
 };
 
 struct PluginMsg_DidReceiveResponseParams {
+  PluginMsg_DidReceiveResponseParams();
+  ~PluginMsg_DidReceiveResponseParams();
+
   unsigned long id;
   std::string mime_type;
   std::string headers;
@@ -63,6 +71,9 @@ struct PluginMsg_DidReceiveResponseParams {
 };
 
 struct NPIdentifier_Param {
+  NPIdentifier_Param();
+  ~NPIdentifier_Param();
+
   NPIdentifier identifier;
 };
 
@@ -83,6 +94,9 @@ enum NPVariant_ParamEnum {
 };
 
 struct NPVariant_Param {
+  NPVariant_Param();
+  ~NPVariant_Param();
+
   NPVariant_ParamEnum type;
   bool bool_value;
   int int_value;
@@ -92,6 +106,9 @@ struct NPVariant_Param {
 };
 
 struct PluginMsg_UpdateGeometry_Param {
+  PluginMsg_UpdateGeometry_Param();
+  ~PluginMsg_UpdateGeometry_Param();
+
   gfx::Rect window_rect;
   gfx::Rect clip_rect;
   TransportDIB::Handle windowless_buffer;
@@ -114,116 +131,25 @@ namespace IPC {
 template <>
 struct ParamTraits<PluginMsg_Init_Params> {
   typedef PluginMsg_Init_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.containing_window);
-    WriteParam(m, p.url);
-    WriteParam(m, p.page_url);
-    DCHECK(p.arg_names.size() == p.arg_values.size());
-    WriteParam(m, p.arg_names);
-    WriteParam(m, p.arg_values);
-    WriteParam(m, p.load_manually);
-    WriteParam(m, p.host_render_view_routing_id);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return ReadParam(m, iter, &p->containing_window) &&
-           ReadParam(m, iter, &p->url) &&
-           ReadParam(m, iter, &p->page_url) &&
-           ReadParam(m, iter, &p->arg_names) &&
-           ReadParam(m, iter, &p->arg_values) &&
-           ReadParam(m, iter, &p->load_manually) &&
-           ReadParam(m, iter, &p->host_render_view_routing_id);
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.containing_window, l);
-    l->append(", ");
-    LogParam(p.url, l);
-    l->append(", ");
-    LogParam(p.page_url, l);
-    l->append(", ");
-    LogParam(p.arg_names, l);
-    l->append(", ");
-    LogParam(p.arg_values, l);
-    l->append(", ");
-    LogParam(p.load_manually, l);
-    l->append(", ");
-    LogParam(p.host_render_view_routing_id, l);
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<PluginHostMsg_URLRequest_Params> {
   typedef PluginHostMsg_URLRequest_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.url);
-    WriteParam(m, p.method);
-    WriteParam(m, p.target);
-    WriteParam(m, p.buffer);
-    WriteParam(m, p.notify_id);
-    WriteParam(m, p.popups_allowed);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->url) &&
-      ReadParam(m, iter, &p->method) &&
-      ReadParam(m, iter, &p->target) &&
-      ReadParam(m, iter, &p->buffer) &&
-      ReadParam(m, iter, &p->notify_id) &&
-      ReadParam(m, iter, &p->popups_allowed);
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.url, l);
-    l->append(", ");
-    LogParam(p.method, l);
-    l->append(", ");
-    LogParam(p.target, l);
-    l->append(", ");
-    LogParam(p.buffer, l);
-    l->append(", ");
-    LogParam(p.notify_id, l);
-    l->append(", ");
-    LogParam(p.popups_allowed, l);
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
 };
 
 template <>
 struct ParamTraits<PluginMsg_DidReceiveResponseParams> {
   typedef PluginMsg_DidReceiveResponseParams param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.id);
-    WriteParam(m, p.mime_type);
-    WriteParam(m, p.headers);
-    WriteParam(m, p.expected_length);
-    WriteParam(m, p.last_modified);
-    WriteParam(m, p.request_is_seekable);
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return
-      ReadParam(m, iter, &r->id) &&
-      ReadParam(m, iter, &r->mime_type) &&
-      ReadParam(m, iter, &r->headers) &&
-      ReadParam(m, iter, &r->expected_length) &&
-      ReadParam(m, iter, &r->last_modified) &&
-      ReadParam(m, iter, &r->request_is_seekable);
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.id, l);
-    l->append(", ");
-    LogParam(p.mime_type, l);
-    l->append(", ");
-    LogParam(p.headers, l);
-    l->append(", ");
-    LogParam(p.expected_length, l);
-    l->append(", ");
-    LogParam(p.last_modified, l);
-    l->append(", ");
-    LogParam(p.request_is_seekable, l);
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
 };
 
 typedef const WebKit::WebInputEvent* WebInputEventPointer;
@@ -290,67 +216,9 @@ struct ParamTraits<NPIdentifier_Param> {
 template <>
 struct ParamTraits<NPVariant_Param> {
   typedef NPVariant_Param param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, static_cast<int>(p.type));
-    if (p.type == NPVARIANT_PARAM_BOOL) {
-      WriteParam(m, p.bool_value);
-    } else if (p.type == NPVARIANT_PARAM_INT) {
-      WriteParam(m, p.int_value);
-    } else if (p.type == NPVARIANT_PARAM_DOUBLE) {
-      WriteParam(m, p.double_value);
-    } else if (p.type == NPVARIANT_PARAM_STRING) {
-      WriteParam(m, p.string_value);
-    } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
-               p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
-      // This is the routing id used to connect NPObjectProxy in the other
-      // process with NPObjectStub in this process or to identify the raw
-      // npobject pointer to be used in the callee process.
-      WriteParam(m, p.npobject_routing_id);
-    } else {
-      DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL);
-    }
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    int type;
-    if (!ReadParam(m, iter, &type))
-      return false;
-
-    bool result = false;
-    r->type = static_cast<NPVariant_ParamEnum>(type);
-    if (r->type == NPVARIANT_PARAM_BOOL) {
-      result = ReadParam(m, iter, &r->bool_value);
-    } else if (r->type == NPVARIANT_PARAM_INT) {
-      result = ReadParam(m, iter, &r->int_value);
-    } else if (r->type == NPVARIANT_PARAM_DOUBLE) {
-      result = ReadParam(m, iter, &r->double_value);
-    } else if (r->type == NPVARIANT_PARAM_STRING) {
-      result = ReadParam(m, iter, &r->string_value);
-    } else if (r->type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
-               r->type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
-      result = ReadParam(m, iter, &r->npobject_routing_id);
-    } else if ((r->type == NPVARIANT_PARAM_VOID) ||
-               (r->type == NPVARIANT_PARAM_NULL)) {
-      result = true;
-    } else {
-      NOTREACHED();
-    }
-
-    return result;
-  }
-  static void Log(const param_type& p, std::string* l) {
-    if (p.type == NPVARIANT_PARAM_BOOL) {
-      LogParam(p.bool_value, l);
-    } else if (p.type == NPVARIANT_PARAM_INT) {
-      LogParam(p.int_value, l);
-    } else if (p.type == NPVARIANT_PARAM_DOUBLE) {
-      LogParam(p.double_value, l);
-    } else if (p.type == NPVARIANT_PARAM_STRING) {
-      LogParam(p.string_value, l);
-    } else if (p.type == NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
-               p.type == NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
-      LogParam(p.npobject_routing_id, l);
-    }
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
 };
 
 // For windowless plugins, windowless_buffer
@@ -360,46 +228,9 @@ struct ParamTraits<NPVariant_Param> {
 template <>
 struct ParamTraits<PluginMsg_UpdateGeometry_Param> {
   typedef PluginMsg_UpdateGeometry_Param param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.window_rect);
-    WriteParam(m, p.clip_rect);
-    WriteParam(m, p.windowless_buffer);
-    WriteParam(m, p.background_buffer);
-    WriteParam(m, p.transparent);
-#if defined(OS_MACOSX)
-    WriteParam(m, p.ack_key);
-#endif
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    return
-      ReadParam(m, iter, &r->window_rect) &&
-      ReadParam(m, iter, &r->clip_rect) &&
-      ReadParam(m, iter, &r->windowless_buffer) &&
-      ReadParam(m, iter, &r->background_buffer) &&
-      ReadParam(m, iter, &r->transparent)
-#if defined(OS_MACOSX)
-      &&
-      ReadParam(m, iter, &r->ack_key)
-#endif
-      ;
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.window_rect, l);
-    l->append(", ");
-    LogParam(p.clip_rect, l);
-    l->append(", ");
-    LogParam(p.windowless_buffer, l);
-    l->append(", ");
-    LogParam(p.background_buffer, l);
-    l->append(", ");
-    LogParam(p.transparent, l);
-#if defined(OS_MACOSX)
-    l->append(", ");
-    LogParam(p.ack_key, l);
-#endif
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* r);
+  static void Log(const param_type& p, std::string* l);
 };
 
 }  // namespace IPC
diff --git a/chrome/common/worker_messages.cc b/chrome/common/worker_messages.cc
index 437e030..192e4fd 100644
--- a/chrome/common/worker_messages.cc
+++ b/chrome/common/worker_messages.cc
@@ -4,6 +4,117 @@
 
 #include "chrome/common/worker_messages.h"
 
+#include "chrome/common/common_param_traits.h"
+
 #define MESSAGES_INTERNAL_IMPL_FILE \
   "chrome/common/worker_messages_internal.h"
 #include "ipc/ipc_message_impl_macros.h"
+
+WorkerHostMsg_PostConsoleMessageToWorkerObject_Params::
+WorkerHostMsg_PostConsoleMessageToWorkerObject_Params()
+    : source_identifier(-1),
+      message_type(-1),
+      message_level(-1),
+      line_number(-1) {
+}
+
+WorkerHostMsg_PostConsoleMessageToWorkerObject_Params::
+~WorkerHostMsg_PostConsoleMessageToWorkerObject_Params() {
+}
+
+WorkerProcessMsg_CreateWorker_Params::WorkerProcessMsg_CreateWorker_Params()
+    : is_shared(false),
+      route_id(-1),
+      creator_process_id(-1),
+      creator_appcache_host_id(-1),
+      shared_worker_appcache_id(-1) {
+}
+
+WorkerProcessMsg_CreateWorker_Params::~WorkerProcessMsg_CreateWorker_Params() {
+}
+
+
+namespace IPC {
+
+void ParamTraits<WorkerHostMsg_PostConsoleMessageToWorkerObject_Params>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.source_identifier);
+  WriteParam(m, p.message_type);
+  WriteParam(m, p.message_level);
+  WriteParam(m, p.message);
+  WriteParam(m, p.line_number);
+  WriteParam(m, p.source_url);
+}
+
+bool ParamTraits<WorkerHostMsg_PostConsoleMessageToWorkerObject_Params>::Read(
+    const Message* m, void** iter, param_type* p) {
+  return
+      ReadParam(m, iter, &p->source_identifier) &&
+      ReadParam(m, iter, &p->message_type) &&
+      ReadParam(m, iter, &p->message_level) &&
+      ReadParam(m, iter, &p->message) &&
+      ReadParam(m, iter, &p->line_number) &&
+      ReadParam(m, iter, &p->source_url);
+}
+
+void ParamTraits<WorkerHostMsg_PostConsoleMessageToWorkerObject_Params>::Log(
+    const param_type& p, std::string* l) {
+  l->append("(");
+  LogParam(p.source_identifier, l);
+  l->append(", ");
+  LogParam(p.message_type, l);
+  l->append(", ");
+  LogParam(p.message_level, l);
+  l->append(", ");
+  LogParam(p.message, l);
+  l->append(", ");
+  LogParam(p.line_number, l);
+  l->append(", ");
+  LogParam(p.source_url, l);
+  l->append(")");
+}
+
+void ParamTraits<WorkerProcessMsg_CreateWorker_Params>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.url);
+  WriteParam(m, p.is_shared);
+  WriteParam(m, p.name);
+  WriteParam(m, p.route_id);
+  WriteParam(m, p.creator_process_id);
+  WriteParam(m, p.creator_appcache_host_id);
+  WriteParam(m, p.shared_worker_appcache_id);
+}
+
+bool ParamTraits<WorkerProcessMsg_CreateWorker_Params>::Read(const Message* m,
+                                                             void** iter,
+                                                             param_type* p) {
+  return
+      ReadParam(m, iter, &p->url) &&
+      ReadParam(m, iter, &p->is_shared) &&
+      ReadParam(m, iter, &p->name) &&
+      ReadParam(m, iter, &p->route_id) &&
+      ReadParam(m, iter, &p->creator_process_id) &&
+      ReadParam(m, iter, &p->creator_appcache_host_id) &&
+      ReadParam(m, iter, &p->shared_worker_appcache_id);
+}
+
+void ParamTraits<WorkerProcessMsg_CreateWorker_Params>::Log(const param_type& p,
+                                                            std::string* l) {
+  l->append("(");
+  LogParam(p.url, l);
+  l->append(", ");
+  LogParam(p.is_shared, l);
+  l->append(", ");
+  LogParam(p.name, l);
+  l->append(", ");
+  LogParam(p.route_id, l);
+  l->append(", ");
+  LogParam(p.creator_process_id, l);
+  l->append(", ");
+  LogParam(p.creator_appcache_host_id, l);
+  l->append(", ");
+  LogParam(p.shared_worker_appcache_id, l);
+  l->append(")");
+}
+
+}  // namespace IPC
diff --git a/chrome/common/worker_messages.h b/chrome/common/worker_messages.h
index 80f876f..0e76c4f 100644
--- a/chrome/common/worker_messages.h
+++ b/chrome/common/worker_messages.h
@@ -13,7 +13,6 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "chrome/common/common_param_traits.h"
 #include "googleurl/src/gurl.h"
 #include "ipc/ipc_message_utils.h"
 
@@ -24,6 +23,9 @@ typedef std::pair<string16, std::vector<int> > QueuedMessage;
 // IPC message. The data members directly correspond to parameters of
 // WebWorkerClient::postConsoleMessageToWorkerObject()
 struct WorkerHostMsg_PostConsoleMessageToWorkerObject_Params {
+  WorkerHostMsg_PostConsoleMessageToWorkerObject_Params();
+  ~WorkerHostMsg_PostConsoleMessageToWorkerObject_Params();
+
   int source_identifier;
   int message_type;
   int message_level;
@@ -34,6 +36,9 @@ struct WorkerHostMsg_PostConsoleMessageToWorkerObject_Params {
 
 // Parameter structure for WorkerProcessMsg_CreateWorker.
 struct WorkerProcessMsg_CreateWorker_Params {
+  WorkerProcessMsg_CreateWorker_Params();
+  ~WorkerProcessMsg_CreateWorker_Params();
+
   GURL url;
   bool is_shared;
   string16 name;
@@ -50,80 +55,18 @@ namespace IPC {
 template <>
 struct ParamTraits<WorkerHostMsg_PostConsoleMessageToWorkerObject_Params> {
   typedef WorkerHostMsg_PostConsoleMessageToWorkerObject_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.source_identifier);
-    WriteParam(m, p.message_type);
-    WriteParam(m, p.message_level);
-    WriteParam(m, p.message);
-    WriteParam(m, p.line_number);
-    WriteParam(m, p.source_url);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->source_identifier) &&
-      ReadParam(m, iter, &p->message_type) &&
-      ReadParam(m, iter, &p->message_level) &&
-      ReadParam(m, iter, &p->message) &&
-      ReadParam(m, iter, &p->line_number) &&
-      ReadParam(m, iter, &p->source_url);
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.source_identifier, l);
-    l->append(", ");
-    LogParam(p.message_type, l);
-    l->append(", ");
-    LogParam(p.message_level, l);
-    l->append(", ");
-    LogParam(p.message, l);
-    l->append(", ");
-    LogParam(p.line_number, l);
-    l->append(", ");
-    LogParam(p.source_url, l);
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
 };
 
 // Traits for WorkerProcessMsg_CreateWorker_Params.
 template <>
 struct ParamTraits<WorkerProcessMsg_CreateWorker_Params> {
   typedef WorkerProcessMsg_CreateWorker_Params param_type;
-  static void Write(Message* m, const param_type& p) {
-    WriteParam(m, p.url);
-    WriteParam(m, p.is_shared);
-    WriteParam(m, p.name);
-    WriteParam(m, p.route_id);
-    WriteParam(m, p.creator_process_id);
-    WriteParam(m, p.creator_appcache_host_id);
-    WriteParam(m, p.shared_worker_appcache_id);
-  }
-  static bool Read(const Message* m, void** iter, param_type* p) {
-    return
-      ReadParam(m, iter, &p->url) &&
-      ReadParam(m, iter, &p->is_shared) &&
-      ReadParam(m, iter, &p->name) &&
-      ReadParam(m, iter, &p->route_id) &&
-      ReadParam(m, iter, &p->creator_process_id) &&
-      ReadParam(m, iter, &p->creator_appcache_host_id) &&
-      ReadParam(m, iter, &p->shared_worker_appcache_id);
-  }
-  static void Log(const param_type& p, std::string* l) {
-    l->append("(");
-    LogParam(p.url, l);
-    l->append(", ");
-    LogParam(p.is_shared, l);
-    l->append(", ");
-    LogParam(p.name, l);
-    l->append(", ");
-    LogParam(p.route_id, l);
-    l->append(", ");
-    LogParam(p.creator_process_id, l);
-    l->append(", ");
-    LogParam(p.creator_appcache_host_id, l);
-    l->append(", ");
-    LogParam(p.shared_worker_appcache_id, l);
-    l->append(")");
-  }
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
 };
 
 }  // namespace IPC
diff --git a/chrome/plugin/chrome_plugin_host.cc b/chrome/plugin/chrome_plugin_host.cc
index a3f66d4..2590182 100644
--- a/chrome/plugin/chrome_plugin_host.cc
+++ b/chrome/plugin/chrome_plugin_host.cc
@@ -9,6 +9,7 @@
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
+#include "base/utf_string_conversions.h"
 #include "base/string_split.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_constants.h"