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

chrome/common/plugin_messages.h

Index: chrome/common/plugin_messages.h
===================================================================
--- chrome/common/plugin_messages.h	(revision 9103)
+++ chrome/common/plugin_messages.h	(working copy)
@@ -15,14 +15,11 @@
 
 #include "base/gfx/rect.h"
 #include "base/basictypes.h"
-#include "chrome/common/ipc_message.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "googleurl/src/gurl.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "webkit/glue/npruntime_util.h"
 
-void PluginMessagesInit();
-
 // Name prefix of the event handle when a message box is displayed.
 #define kMessageBoxEventPrefix L"message_box_active"
 
@@ -38,95 +35,11 @@
   HANDLE modal_dialog_event;
 };
 
-struct PluginHostMsg_URLRequest_Params {
-  std::string method;
-  bool is_javascript_url;
-  std::string target;
-  std::vector<char> buffer;
-  bool is_file_data;
-  bool notify;
-  std::string url;
-  HANDLE notify_data;
-  bool popups_allowed;
-};
-
-struct PluginMsg_URLRequestReply_Params {
-  int resource_id;
-  std::string url;
-  bool notify_needed;
-  HANDLE notify_data;
-  HANDLE stream;
-};
-
-struct PluginMsg_PrintResponse_Params {
-  HANDLE shared_memory;
-  size_t size;
-};
-
-struct PluginMsg_DidReceiveResponseParams {
-  int id;
-  std::string mime_type;
-  std::string headers;
-  uint32 expected_length;
-  uint32 last_modified;
-  bool request_is_seekable;
-};
-
-struct NPIdentifier_Param {
-  NPIdentifier identifier;
-};
-
-enum NPVariant_ParamEnum {
-  NPVARIANT_PARAM_VOID,
-  NPVARIANT_PARAM_NULL,
-  NPVARIANT_PARAM_BOOL,
-  NPVARIANT_PARAM_INT,
-  NPVARIANT_PARAM_DOUBLE,
-  NPVARIANT_PARAM_STRING,
-  // Used when when the NPObject is running in the caller's process, so we
-  // create an NPObjectProxy in the other process.
-  NPVARIANT_PARAM_OBJECT_ROUTING_ID,
-  // Used when the NPObject we're sending is running in the callee's process
-  // (i.e. we have an NPObjectProxy for it).  In that case we want the callee
-  // to just use the raw pointer.
-  NPVARIANT_PARAM_OBJECT_POINTER,
-};
-
-struct NPVariant_Param {
-  NPVariant_ParamEnum type;
-  bool bool_value;
-  int int_value;
-  double double_value;
-  std::string string_value;
-  int npobject_routing_id;
-  void* npobject_pointer;
-};
-
-
-#define IPC_MESSAGE_MACROS_ENUMS
-#include "chrome/common/plugin_messages_internal.h"
-
-#ifdef IPC_MESSAGE_MACROS_LOG_ENABLED
-#  undef IPC_MESSAGE_MACROS_LOG
-#  define IPC_MESSAGE_MACROS_CLASSES
-
-#  include "chrome/common/plugin_messages_internal.h"
-#  define IPC_MESSAGE_MACROS_LOG
-#  undef IPC_MESSAGE_MACROS_CLASSES
-
-#  include "chrome/common/plugin_messages_internal.h"
-#else
-#  define IPC_MESSAGE_MACROS_CLASSES
-#  include "chrome/common/plugin_messages_internal.h"
-#endif
-
-namespace IPC {
-
 // Traits for PluginMsg_Init_Params structure to pack/unpack.
 template <>
 struct ParamTraits<PluginMsg_Init_Params> {
   typedef PluginMsg_Init_Params param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.containing_window);
     WriteParam(m, p.url);
     DCHECK(p.arg_names.size() == p.arg_values.size());
@@ -135,7 +48,7 @@
     WriteParam(m, p.load_manually);
     WriteParam(m, p.modal_dialog_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->containing_window) &&
            ReadParam(m, iter, &p->url) &&
            ReadParam(m, iter, &p->arg_names) &&
@@ -160,10 +73,23 @@
   }
 };
 
+
+struct PluginHostMsg_URLRequest_Params {
+  std::string method;
+  bool is_javascript_url;
+  std::string target;
+  std::vector<char> buffer;
+  bool is_file_data;
+  bool notify;
+  std::string url;
+  HANDLE notify_data;
+  bool popups_allowed;
+};
+
 template <>
 struct ParamTraits<PluginHostMsg_URLRequest_Params> {
   typedef PluginHostMsg_URLRequest_Params param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.method);
     WriteParam(m, p.is_javascript_url);
     WriteParam(m, p.target);
@@ -174,7 +100,7 @@
     WriteParam(m, p.notify_data);
     WriteParam(m, p.popups_allowed);
   }
-  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->method) &&
       ReadParam(m, iter, &p->is_javascript_url) &&
@@ -209,17 +135,26 @@
   }
 };
 
+
+struct PluginMsg_URLRequestReply_Params {
+  int resource_id;
+  std::string url;
+  bool notify_needed;
+  HANDLE notify_data;
+  HANDLE stream;
+};
+
 template <>
 struct ParamTraits<PluginMsg_URLRequestReply_Params> {
   typedef PluginMsg_URLRequestReply_Params param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.resource_id);
     WriteParam(m, p.url);
     WriteParam(m, p.notify_needed);
     WriteParam(m, p.notify_data);
     WriteParam(m, p.stream);
   }
-  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->resource_id) &&
       ReadParam(m, iter, &p->url) &&
@@ -242,14 +177,20 @@
   }
 };
 
+
+struct PluginMsg_PrintResponse_Params {
+  HANDLE shared_memory;
+  size_t size;
+};
+
 template <>
 struct ParamTraits<PluginMsg_PrintResponse_Params> {
   typedef PluginMsg_PrintResponse_Params param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.shared_memory);
     WriteParam(m, p.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->shared_memory) &&
       ReadParam(m, iter, &r->size);
@@ -258,10 +199,20 @@
   }
 };
 
+
+struct PluginMsg_DidReceiveResponseParams {
+  int id;
+  std::string mime_type;
+  std::string headers;
+  uint32 expected_length;
+  uint32 last_modified;
+  bool request_is_seekable;
+};
+
 template <>
 struct ParamTraits<PluginMsg_DidReceiveResponseParams> {
   typedef PluginMsg_DidReceiveResponseParams param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     WriteParam(m, p.id);
     WriteParam(m, p.mime_type);
     WriteParam(m, p.headers);
@@ -269,7 +220,7 @@
     WriteParam(m, p.last_modified);
     WriteParam(m, p.request_is_seekable);
   }
-  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->id) &&
       ReadParam(m, iter, &r->mime_type) &&
@@ -295,97 +246,18 @@
   }
 };
 
-template <>
-struct ParamTraits<NPEvent> {
-  typedef NPEvent param_type;
-  static void Write(Message* m, const param_type& p) {
-    m->WriteData(reinterpret_cast<const char*>(&p), sizeof(NPEvent));
-  }
-  static bool Read(const Message* m, void** iter, param_type* r) {
-    const char *data;
-    int data_size = 0;
-    bool result = m->ReadData(iter, &data, &data_size);
-    if (!result || data_size != sizeof(NPEvent)) {
-      NOTREACHED();
-      return false;
-    }
 
-    memcpy(r, data, sizeof(NPEvent));
-    return true;
-  }
-  static void Log(const param_type& p, std::wstring* l) {
-    std::wstring event, wparam, lparam;
-    lparam = StringPrintf(L"(%d, %d)", LOWORD(p.lParam), HIWORD(p.lParam));
-    switch(p.event) {
-     case WM_KEYDOWN:
-      event = L"WM_KEYDOWN";
-      wparam = StringPrintf(L"%d", p.wParam);
-      lparam = StringPrintf(L"%d", p.lParam);
-      break;
-     case WM_KEYUP:
-      event = L"WM_KEYDOWN";
-      wparam = StringPrintf(L"%d", p.wParam);
-      lparam = StringPrintf(L"%x", p.lParam);
-      break;
-     case WM_MOUSEMOVE:
-      event = L"WM_MOUSEMOVE";
-      if (p.wParam & MK_LBUTTON) {
-        wparam = L"MK_LBUTTON";
-      } else if (p.wParam & MK_MBUTTON) {
-        wparam = L"MK_MBUTTON";
-      } else if (p.wParam & MK_RBUTTON) {
-        wparam = L"MK_RBUTTON";
-      }
-      break;
-     case WM_LBUTTONDOWN:
-      event = L"WM_LBUTTONDOWN";
-      break;
-     case WM_MBUTTONDOWN:
-      event = L"WM_MBUTTONDOWN";
-      break;
-     case WM_RBUTTONDOWN:
-      event = L"WM_RBUTTONDOWN";
-      break;
-     case WM_LBUTTONUP:
-      event = L"WM_LBUTTONUP";
-      break;
-     case WM_MBUTTONUP:
-      event = L"WM_MBUTTONUP";
-      break;
-     case WM_RBUTTONUP:
-      event = L"WM_RBUTTONUP";
-      break;
-    }
-
-    if (p.wParam & MK_CONTROL) {
-      if (!wparam.empty())
-        wparam += L" ";
-      wparam += L"MK_CONTROL";
-    }
-
-    if (p.wParam & MK_SHIFT) {
-      if (!wparam.empty())
-        wparam += L" ";
-      wparam += L"MK_SHIFT";
-    }
-
-    l->append(L"(");
-    LogParam(event, l);
-    l->append(L", ");
-    LogParam(wparam, l);
-    l->append(L", ");
-    LogParam(lparam, l);
-    l->append(L")");
-  }
+struct NPIdentifier_Param {
+  NPIdentifier identifier;
 };
 
 template <>
 struct ParamTraits<NPIdentifier_Param> {
   typedef NPIdentifier_Param param_type;
-  static void Write(Message* m, const param_type& p) {
+  static void Write(IPC::Message* m, const param_type& p) {
     webkit_glue::SerializeNPIdentifier(p.identifier, m);
   }
-  static bool Read(const Message* m, void** iter, param_type* r) {
+  static bool Read(const IPC::Message* m, void** iter, param_type* r) {
     return webkit_glue::DeserializeNPIdentifier(*m, iter, &r->identifier);
   }
   static void Log(const param_type& p, std::wstring* l) {
@@ -399,10 +271,37 @@
   }
 };
 
+
+enum NPVariant_ParamEnum {
+  NPVARIANT_PARAM_VOID,
+  NPVARIANT_PARAM_NULL,
+  NPVARIANT_PARAM_BOOL,
+  NPVARIANT_PARAM_INT,
+  NPVARIANT_PARAM_DOUBLE,
+  NPVARIANT_PARAM_STRING,
+  // Used when when the NPObject is running in the caller's process, so we
+  // create an NPObjectProxy in the other process.
+  NPVARIANT_PARAM_OBJECT_ROUTING_ID,
+  // Used when the NPObject we're sending is running in the callee's process
+  // (i.e. we have an NPObjectProxy for it).  In that case we want the callee
+  // to just use the raw pointer.
+  NPVARIANT_PARAM_OBJECT_POINTER,
+};
+
+struct NPVariant_Param {
+  NPVariant_ParamEnum type;
+  bool bool_value;
+  int int_value;
+  double double_value;
+  std::string string_value;
+  int npobject_routing_id;
+  void* npobject_pointer;
+};
+
 template <>
 struct ParamTraits<NPVariant_Param> {
   typedef NPVariant_Param 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 == NPVARIANT_PARAM_BOOL) {
       WriteParam(m, p.bool_value);
@@ -425,7 +324,7 @@
       DCHECK(p.type == NPVARIANT_PARAM_VOID || p.type == NPVARIANT_PARAM_NULL);
     }
   }
-  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;
@@ -473,7 +372,94 @@
   }
 };
 
-}  // namespace IPC
 
+template <>
+struct ParamTraits<NPEvent> {
+  typedef NPEvent param_type;
+  static void Write(IPC::Message* m, const param_type& p) {
+    m->WriteData(reinterpret_cast<const char*>(&p), sizeof(NPEvent));
+  }
+  static bool Read(const IPC::Message* m, void** iter, param_type* r) {
+    const char *data;
+    int data_size = 0;
+    bool result = m->ReadData(iter, &data, &data_size);
+    if (!result || data_size != sizeof(NPEvent)) {
+      NOTREACHED();
+      return false;
+    }
+
+    memcpy(r, data, sizeof(NPEvent));
+    return true;
+  }
+  static void Log(const param_type& p, std::wstring* l) {
+    std::wstring event, wparam, lparam;
+    lparam = StringPrintf(L"(%d, %d)", LOWORD(p.lParam), HIWORD(p.lParam));
+    switch(p.event) {
+     case WM_KEYDOWN:
+      event = L"WM_KEYDOWN";
+      wparam = StringPrintf(L"%d", p.wParam);
+      lparam = StringPrintf(L"%d", p.lParam);
+      break;
+     case WM_KEYUP:
+      event = L"WM_KEYDOWN";
+      wparam = StringPrintf(L"%d", p.wParam);
+      lparam = StringPrintf(L"%x", p.lParam);
+      break;
+     case WM_MOUSEMOVE:
+      event = L"WM_MOUSEMOVE";
+      if (p.wParam & MK_LBUTTON) {
+        wparam = L"MK_LBUTTON";
+      } else if (p.wParam & MK_MBUTTON) {
+        wparam = L"MK_MBUTTON";
+      } else if (p.wParam & MK_RBUTTON) {
+        wparam = L"MK_RBUTTON";
+      }
+      break;
+     case WM_LBUTTONDOWN:
+      event = L"WM_LBUTTONDOWN";
+      break;
+     case WM_MBUTTONDOWN:
+      event = L"WM_MBUTTONDOWN";
+      break;
+     case WM_RBUTTONDOWN:
+      event = L"WM_RBUTTONDOWN";
+      break;
+     case WM_LBUTTONUP:
+      event = L"WM_LBUTTONUP";
+      break;
+     case WM_MBUTTONUP:
+      event = L"WM_MBUTTONUP";
+      break;
+     case WM_RBUTTONUP:
+      event = L"WM_RBUTTONUP";
+      break;
+    }
+
+    if (p.wParam & MK_CONTROL) {
+      if (!wparam.empty())
+        wparam += L" ";
+      wparam += L"MK_CONTROL";
+    }
+
+    if (p.wParam & MK_SHIFT) {
+      if (!wparam.empty())
+        wparam += L" ";
+      wparam += L"MK_SHIFT";
+    }
+
+    l->append(L"(");
+    LogParam(event, l);
+    l->append(L", ");
+    LogParam(wparam, l);
+    l->append(L", ");
+    LogParam(lparam, l);
+    l->append(L")");
+  }
+};
+
+
+#define MESSAGES_INTERNAL_FILE "chrome/common/plugin_messages_internal.h"
+#include "chrome/common/ipc_message_macros.h"
+
 #endif  // CHROME_COMMON_PLUGIN_MESSAGES_H__