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

chrome/common/plugin_messages_internal.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.
 
 #include "base/shared_memory.h"
 #include "chrome/common/ipc_message_macros.h"
 #include "webkit/glue/webcursor.h"
 
 //-----------------------------------------------------------------------------
 // PluginProcess messages
 // These are messages sent from the browser to the plugin process.
-IPC_BEGIN_MESSAGES(PluginProcess, 3)
+IPC_BEGIN_MESSAGES(PluginProcess)
   // Tells the plugin process to create a new channel for communication with a
   // renderer.  The channel name is returned in a
   // PluginProcessHostMsg_ChannelCreated message.
   // The renderer_handle is the handle of the renderer process requesting
   // the channel. It has to be valid in the context of the plugin process.
   IPC_MESSAGE_CONTROL2(PluginProcessMsg_CreateChannel,
                        int /* process_id */,
                        HANDLE /* renderer handle */)
 
   IPC_MESSAGE_CONTROL1(PluginProcessMsg_ShutdownResponse,
                        bool /* ok to shutdown */)
 
   // Allows a chrome plugin loaded in the browser process to send arbitrary
   // data to an instance of the same plugin loaded in a plugin process.
   IPC_MESSAGE_CONTROL1(PluginProcessMsg_PluginMessage,
                        std::vector<uint8> /* opaque data */)
 
   IPC_MESSAGE_CONTROL0(PluginProcessMsg_BrowserShutdown)
 
 IPC_END_MESSAGES(PluginProcess)
 
 
 //-----------------------------------------------------------------------------
 // PluginProcessHost messages
 // These are messages sent from the plugin process to the browser process.
-IPC_BEGIN_MESSAGES(PluginProcessHost, 4)
+IPC_BEGIN_MESSAGES(PluginProcessHost)
   // Response to a PluginProcessMsg_CreateChannel message.
   IPC_MESSAGE_CONTROL2(PluginProcessHostMsg_ChannelCreated,
                        int /* process_id */,
                        std::wstring /* channel_name */)
 
   IPC_MESSAGE_ROUTED3(PluginProcessHostMsg_DownloadUrl,
                       std::string /* URL */,
                       int /* process id */,
                       HWND /* caller window */)
 
@@ skipping 36 matching lines @@
   // Destroys the given window on the UI thread.
   IPC_MESSAGE_CONTROL1(PluginProcessHostMsg_DestroyWindow,
                        HWND /* window */)
 
 IPC_END_MESSAGES(PluginProcessHost)
 
 
 //-----------------------------------------------------------------------------
 // Plugin messages
 // These are messages sent from the renderer process to the plugin process.
-IPC_BEGIN_MESSAGES(Plugin, 5)
+IPC_BEGIN_MESSAGES(Plugin)
   // Tells the plugin process to create a new plugin instance with the given
   // id.  A corresponding WebPluginDelegateStub is created which hosts the
   // WebPluginDelegateImpl.
   IPC_SYNC_MESSAGE_CONTROL1_1(PluginMsg_CreateInstance,
                               std::string /* mime_type */,
                               int /* instance_id */)
 
   // The WebPluginDelegateProxy sends this to the WebPluginDelegateStub in its
   // destructor, so that the stub deletes the actual WebPluginDelegateImpl
   // object that it's hosting.
@@ skipping 89 matching lines @@
                              std::string /* url */,
                              bool /* notify_needed */,
                              HANDLE /* notify data */)
 IPC_END_MESSAGES(Plugin)
 
 
 //-----------------------------------------------------------------------------
 // PluginHost messages
 // These are messages sent from the plugin process to the renderer process.
 // They all map to the corresponding WebPlugin methods.
-IPC_BEGIN_MESSAGES(PluginHost, 6)
+IPC_BEGIN_MESSAGES(PluginHost)
   // Sends the plugin window information to the renderer.
   // The window parameter is a handle to the window if the plugin is a windowed
   // plugin. It is NULL for windowless plugins.
   // The modal_loop_pump_messages_event parameter is an event handle which is
   // passed in for windowless plugins and is used to indicate if messages
   // are to be pumped in sync calls to the plugin process. Currently used
   // in HandleEvent calls.
   IPC_SYNC_MESSAGE_ROUTED2_0(PluginHostMsg_SetWindow,
                              HWND /* window */,
                              HANDLE /* modal_loop_pump_messages_event */)
@@ skipping 51 matching lines @@
                       HANDLE      /* existing_stream */,
                       bool        /* notify_needed */,
                       HANDLE      /* notify_data */)
 
 IPC_END_MESSAGES(PluginHost)
 
 //-----------------------------------------------------------------------------
 // NPObject messages
 // These are messages used to marshall NPObjects.  They are sent both from the
 // plugin to the renderer and from the renderer to the plugin.
-IPC_BEGIN_MESSAGES(NPObject, 7)
+IPC_BEGIN_MESSAGES(NPObject)
   IPC_SYNC_MESSAGE_ROUTED0_0(NPObjectMsg_Release)
 
   IPC_SYNC_MESSAGE_ROUTED1_1(NPObjectMsg_HasMethod,
                              NPIdentifier_Param /* name */,
                              bool /* result */)
 
   IPC_SYNC_MESSAGE_ROUTED3_2(NPObjectMsg_Invoke,
                              bool /* is_default */,
                              NPIdentifier_Param /* method */,
                              std::vector<NPVariant_Param> /* args */,
@@ skipping 28 matching lines @@
                              std::string /* script */,
                              bool /* popups_allowed */,
                              NPVariant_Param /* result_param */,
                              bool /* result */)
 
   IPC_SYNC_MESSAGE_ROUTED1_0(NPObjectMsg_SetException,
                              std::string /* message */)
 
 IPC_END_MESSAGES(NPObject)