Provide IPC mechanism for host-to-resource messaging

ppapi/proxy/websocket_resource.cc

 // Copyright (c) 2012 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 "ppapi/proxy/websocket_resource.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/dispatch_reply_message.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSocket.h"
 
 namespace {
 
 const uint32_t kMaxReasonSizeInBytes = 123;
 const size_t kBaseFramingOverhead = 2;
@@ skipping 300 matching lines @@
 
 PP_Var WebSocketResource::GetURL() {
   if (!url_)
     return empty_string_->GetPPVar();
   return url_->GetPPVar();
 }
 
 void WebSocketResource::OnReplyReceived(
     const ResourceMessageReplyParams& params,
     const IPC::Message& msg) {
-  if (params.sequence())
-    return PluginResource::OnReplyReceived(params, msg);
+  if (params.sequence()) {
+    PluginResource::OnReplyReceived(params, msg);
+    return;
+  }
 
-  // TODO(toyoshim): Currently, following unsolicited reply IPCs are handled
-  // manually. We should introduce more useful mechanism for that.
-  switch (msg.type()) {
-    case PpapiPluginMsg_WebSocket_ReceiveTextReply::ID: {
-      PpapiPluginMsg_WebSocket_ReceiveTextReply::Schema::Param p;
-      if (PpapiPluginMsg_WebSocket_ReceiveTextReply::Read(&msg, &p))
-        OnPluginMsgReceiveTextReply(params, p.a);
-      else
-        NOTREACHED();
-      break;
-    }
-    case PpapiPluginMsg_WebSocket_ReceiveBinaryReply::ID: {
-      PpapiPluginMsg_WebSocket_ReceiveBinaryReply::Schema::Param p;
-      if (PpapiPluginMsg_WebSocket_ReceiveBinaryReply::Read(&msg, &p))
-        OnPluginMsgReceiveBinaryReply(params, p.a);
-      else
-        NOTREACHED();
-      break;
-    }
-    case PpapiPluginMsg_WebSocket_ErrorReply::ID: {
-      OnPluginMsgErrorReply(params);
-      break;
-    }
-    case PpapiPluginMsg_WebSocket_BufferedAmountReply::ID: {
-      PpapiPluginMsg_WebSocket_BufferedAmountReply::Schema::Param p;
-      if (PpapiPluginMsg_WebSocket_BufferedAmountReply::Read(&msg, &p))
-        OnPluginMsgBufferedAmountReply(params, p.a);
-      else
-        NOTREACHED();
-      break;
-    }
-    case PpapiPluginMsg_WebSocket_StateReply::ID: {
-      PpapiPluginMsg_WebSocket_StateReply::Schema::Param p;
-      if (PpapiPluginMsg_WebSocket_StateReply::Read(&msg, &p))
-        OnPluginMsgStateReply(params, p.a);
-      else
-        NOTREACHED();
-      break;
-    }
-    case PpapiPluginMsg_WebSocket_ClosedReply::ID: {
-      PpapiPluginMsg_WebSocket_ClosedReply::Schema::Param p;
-      if (PpapiPluginMsg_WebSocket_ClosedReply::Read(&msg, &p))
-        OnPluginMsgClosedReply(params, p.a, p.b, p.c, p.d);
-      else
-        NOTREACHED();
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
+  IPC_BEGIN_MESSAGE_MAP(WebSocketResource, msg)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_WebSocket_ReceiveTextReply,
+        OnPluginMsgReceiveTextReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_WebSocket_ReceiveBinaryReply,
+        OnPluginMsgReceiveBinaryReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_0(
+        PpapiPluginMsg_WebSocket_ErrorReply,
+        OnPluginMsgErrorReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_WebSocket_BufferedAmountReply,
+        OnPluginMsgBufferedAmountReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_WebSocket_StateReply,
+        OnPluginMsgStateReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_WebSocket_ClosedReply,
+        OnPluginMsgClosedReply)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(NOTREACHED())
+  IPC_END_MESSAGE_MAP()
 }
 
 void WebSocketResource::OnPluginMsgConnectReply(
     const ResourceMessageReplyParams& params,
     const std::string& url,
     const std::string& protocol) {
   if (!TrackedCallback::IsPending(connect_callback_))
     return;
 
   int32_t result = params.result();
@@ skipping 105 matching lines @@
     return PP_OK;
 
   *receive_callback_var_ = received_messages_.front()->GetPPVar();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi