PPB_UDPSocket_Private is switched to the new Pepper proxy.

content/browser/renderer_host/pepper/pepper_udp_socket_private_host.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 "content/browser/renderer_host/pepper/pepper_udp_socket_private_host.h"
+
+#include <vector>
+
+#include "base/logging.h"
+#include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
+#include "content/browser/renderer_host/pepper/pepper_utils.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/common/process_type.h"
+#include "content/public/common/socket_permission_request.h"
+#include "ipc/ipc_message_macros.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/host_message_context.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/proxy/ppapi_messages.h"
+
+namespace content {
+
+PepperUDPSocketPrivateHost::PepperUDPSocketPrivateHost(
+    BrowserPpapiHostImpl* host,
+    PP_Instance instance,
+    PP_Resource resource)
+    : ResourceHost(host->GetPpapiHost(), instance, resource),
+      host_(host),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+  DCHECK(host_);
+}
+
+PepperUDPSocketPrivateHost::~PepperUDPSocketPrivateHost() {
+}
+
+int32_t PepperUDPSocketPrivateHost::OnResourceMessageReceived(
+    const IPC::Message& msg,
+    ppapi::host::HostMessageContext* context) {
+  IPC_BEGIN_MESSAGE_MAP(PepperUDPSocketPrivateHost, msg)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_UDPSocketPrivate_SetBoolSocketFeature,
+        OnMsgSetBoolSocketFeature)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_UDPSocketPrivate_Bind,
+        OnMsgBind)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(
+        PpapiHostMsg_UDPSocketPrivate_RecvFrom,
+        OnMsgRecvFrom)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_UDPSocketPrivate_SendTo,
+        OnMsgSendTo)
+    PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(
+        PpapiHostMsg_UDPSocketPrivate_Close,
+        OnMsgClose)
+  IPC_END_MESSAGE_MAP()
+  return PP_ERROR_FAILED;
+}
+
+int32_t PepperUDPSocketPrivateHost::OnMsgSetBoolSocketFeature(
+    const ppapi::host::HostMessageContext* context,
+    int32_t name,
+    bool value) {
+  SetBoolSocketFeature(name, value);
+  return PP_OK;
+}
+
+int32_t PepperUDPSocketPrivateHost::OnMsgBind(
+    const ppapi::host::HostMessageContext* context,
+    const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(context);
+
+  if (bind_context_.get())
+    return PP_ERROR_INPROGRESS;
+  bind_context_.reset(
+      new ppapi::host::ReplyMessageContext(context->MakeReplyMessageContext()));
+
+  SocketPermissionRequest params = PepperUtils::CreateSocketPermissionRequest(
+      SocketPermissionRequest::UDP_BIND, addr);
+  CheckSocketPermissionsAndReply(params,
+                                 base::Bind(&PepperUDPSocketPrivateHost::DoBind,
+                                            weak_factory_.GetWeakPtr(),
+                                            addr));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void PepperUDPSocketPrivateHost::DoBind(const PP_NetAddress_Private& addr,
+                                        bool allowed) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!allowed) {
+    SendBindError();
+    return;
+  }
+  Bind(addr);
+}
+
+int32_t PepperUDPSocketPrivateHost::OnMsgRecvFrom(
+    const ppapi::host::HostMessageContext* context,
+    int32_t num_bytes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(context);
+
+  if (recv_from_context_.get())
+    return PP_ERROR_INPROGRESS;
+  recv_from_context_.reset(
+      new ppapi::host::ReplyMessageContext(context->MakeReplyMessageContext()));
+  RecvFrom(num_bytes);
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperUDPSocketPrivateHost::OnMsgSendTo(
+    const ppapi::host::HostMessageContext* context,
+    const std::string& data,
+    const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(context);
+
+  if (send_to_context_.get())
+    return PP_ERROR_INPROGRESS;
+  send_to_context_.reset(
+      new ppapi::host::ReplyMessageContext(context->MakeReplyMessageContext()));
+  SocketPermissionRequest params = PepperUtils::CreateSocketPermissionRequest(
+      SocketPermissionRequest::UDP_SEND_TO, addr);
+  CheckSocketPermissionsAndReply(params,
+                                 base::Bind(
+                                     &PepperUDPSocketPrivateHost::DoSendTo,
+                                     weak_factory_.GetWeakPtr(),
+                                     data,
+                                     addr));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void PepperUDPSocketPrivateHost::DoSendTo(const std::string& data,
+                                          const PP_NetAddress_Private& addr,
+                                          bool allowed) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!allowed) {
+    SendSendToError();
+    return;
+  }
+  SendTo(data, addr);
+}
+
+int32_t PepperUDPSocketPrivateHost::OnMsgClose(
+    const ppapi::host::HostMessageContext* context) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  Close();
+  return PP_OK;
+}
+
+void PepperUDPSocketPrivateHost::SendBindReply(
+    bool succeeded,
+    const PP_NetAddress_Private& addr) {
+  DCHECK(bind_context_.get());
+
+  scoped_ptr<ppapi::host::ReplyMessageContext> context(bind_context_.release());
+  host()->SendReply(*context,
+                    PpapiPluginMsg_UDPSocketPrivate_BindReply(succeeded, addr));
+}
+
+void PepperUDPSocketPrivateHost::SendRecvFromReply(
+    bool succeeded,
+    const std::string& data,
+    const PP_NetAddress_Private& addr) {
+  DCHECK(recv_from_context_.get());
+
+  scoped_ptr<ppapi::host::ReplyMessageContext> context(
+      recv_from_context_.release());
+  host()->SendReply(*context,
+                    PpapiPluginMsg_UDPSocketPrivate_RecvFromReply(succeeded,
+                                                                  data,
+                                                                  addr));
+}
+
+void PepperUDPSocketPrivateHost::SendSendToReply(bool succeeded,
+                                                 int32_t bytes_written) {
+  DCHECK(send_to_context_.get());
+
+  scoped_ptr<ppapi::host::ReplyMessageContext> context(
+      send_to_context_.release());
+  host()->SendReply(*context,
+                    PpapiPluginMsg_UDPSocketPrivate_SendToReply(succeeded,
+                                                                bytes_written));
+}
+
+void PepperUDPSocketPrivateHost::CheckSocketPermissionsAndReply(
+    const SocketPermissionRequest& params,
+    const RequestCallback& callback) {
+  host_->PostOnUIThreadWithRenderViewHostAndReply(
+      FROM_HERE,
+      pp_instance(),
+      base::Bind(&PepperUtils::CanUseSocketAPIs,
+                 host_->plugin_process_type(), params),
+      callback);
+}
+
+}  // namespace content