PluginResource: Avoid having two sets of similar methods for talking with browser and renderer.

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"
@@ skipping 98 matching lines @@
 
     protocol_strings.push_back(protocol->value());
   }
 
   // Install callback.
   connect_callback_ = callback;
 
   // Create remote host in the renderer, then request to check the URL and
   // establish the connection.
   state_ = PP_WEBSOCKETREADYSTATE_CONNECTING;
-  SendCreateToRenderer(PpapiHostMsg_WebSocket_Create());
+  SendCreate(RENDERER, PpapiHostMsg_WebSocket_Create());
   PpapiHostMsg_WebSocket_Connect msg(url_->value(), protocol_strings);
-  CallRenderer<PpapiPluginMsg_WebSocket_ConnectReply>(msg,
+  Call<PpapiPluginMsg_WebSocket_ConnectReply>(RENDERER, msg,
       base::Bind(&WebSocketResource::OnPluginMsgConnectReply, this));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t WebSocketResource::Close(uint16_t code,
                                  const PP_Var& reason,
                                  scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(close_callback_))
     return PP_ERROR_INPROGRESS;
@@ skipping 39 matching lines @@
 
   // Install |callback|.
   close_callback_ = callback;
 
   // Abort ongoing connect.
   if (TrackedCallback::IsPending(connect_callback_)) {
     state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
     // Need to do a "Post" to avoid reentering the plugin.
     connect_callback_->PostAbort();
     connect_callback_ = NULL;
-    PostToRenderer(PpapiHostMsg_WebSocket_Fail(
+    Post(RENDERER, PpapiHostMsg_WebSocket_Fail(
         "WebSocket was closed before the connection was established."));
     return PP_OK_COMPLETIONPENDING;
   }
 
   // Abort ongoing receive.
   if (TrackedCallback::IsPending(receive_callback_)) {
     receive_callback_var_ = NULL;
     // Need to do a "Post" to avoid reentering the plugin.
     receive_callback_->PostAbort();
     receive_callback_ = NULL;
   }
 
   // Close connection.
   state_ = PP_WEBSOCKETREADYSTATE_CLOSING;
   PpapiHostMsg_WebSocket_Close msg(static_cast<int32_t>(event_code),
                                    reason_string);
-  CallRenderer<PpapiPluginMsg_WebSocket_CloseReply>(msg,
+  Call<PpapiPluginMsg_WebSocket_CloseReply>(RENDERER, msg,
       base::Bind(&WebSocketResource::OnPluginMsgCloseReply, this));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t WebSocketResource::ReceiveMessage(
     PP_Var* message,
     scoped_refptr<TrackedCallback> callback) {
   if (TrackedCallback::IsPending(receive_callback_))
     return PP_ERROR_INPROGRESS;
 
@@ skipping 53 matching lines @@
 
     return PP_ERROR_FAILED;
   }
 
   // Send the message.
   if (message.type == PP_VARTYPE_STRING) {
     // Convert message to std::string, then send it.
     scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
     if (!message_string)
       return PP_ERROR_BADARGUMENT;
-    PostToRenderer(PpapiHostMsg_WebSocket_SendText(message_string->value()));
+    Post(RENDERER, PpapiHostMsg_WebSocket_SendText(message_string->value()));
   } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
     // Convert message to std::vector<uint8_t>, then send it.
     scoped_refptr<ArrayBufferVar> message_arraybuffer =
         ArrayBufferVar::FromPPVar(message);
     if (!message_arraybuffer)
       return PP_ERROR_BADARGUMENT;
     uint8_t* message_data = static_cast<uint8_t*>(message_arraybuffer->Map());
     uint32 message_length = message_arraybuffer->ByteLength();
     std::vector<uint8_t> message_vector(message_data,
                                         message_data + message_length);
-    PostToRenderer(PpapiHostMsg_WebSocket_SendBinary(message_vector));
+    Post(RENDERER, PpapiHostMsg_WebSocket_SendBinary(message_vector));
   } else {
     // TODO(toyoshim): Support Blob.
     return PP_ERROR_NOTSUPPORTED;
   }
   return PP_OK;
 }
 
 uint64_t WebSocketResource::GetBufferedAmount() {
   return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 }
@@ skipping 206 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