PPB_UDPSocket_Private is switched to the new Pepper proxy.

content/browser/renderer_host/pepper/pepper_udp_socket.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.h"
 
-#include <string.h>
-
-#include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/pepper/pepper_message_filter.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/base/io_buffer.h"
-#include "net/base/net_errors.h"
-#include "net/udp/udp_server_socket.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/shared_impl/private/net_address_private_impl.h"
-
-using ppapi::NetAddressPrivateImpl;
 
 namespace content {
 
 PepperUDPSocket::PepperUDPSocket(
     PepperMessageFilter* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
     uint32 socket_id)
     : manager_(manager),
       routing_id_(routing_id),
       plugin_dispatcher_id_(plugin_dispatcher_id),
-      socket_id_(socket_id),
-      allow_address_reuse_(false),
-      allow_broadcast_(false) {
+      socket_id_(socket_id) {
   DCHECK(manager);
 }
 
 PepperUDPSocket::~PepperUDPSocket() {
-  // Make sure there are no further callbacks from socket_.
-  if (socket_.get())
-    socket_->Close();
 }
 
-void PepperUDPSocket::AllowAddressReuse(bool value) {
-  allow_address_reuse_ = value;
+void PepperUDPSocket::SendBindReply(bool succeeded,
+                                    const PP_NetAddress_Private& addr) {
+  manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, succeeded, addr));
 }
 
-void PepperUDPSocket::AllowBroadcast(bool value) {
-  allow_broadcast_ = value;
+void PepperUDPSocket::SendSendToReply(bool succeeded, int32_t bytes_written) {
+  manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_,
+      succeeded, bytes_written));
 }
 
-void PepperUDPSocket::Bind(const PP_NetAddress_Private& addr) {
-  socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
-
-  net::IPAddressNumber address;
-  int port;
-  if (!socket_.get() ||
-      !NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
-    SendBindACKError();
-    return;
-  }
-
-  if (allow_address_reuse_)
-    socket_->AllowAddressReuse();
-  if (allow_broadcast_)
-    socket_->AllowBroadcast();
-
-  int result = socket_->Listen(net::IPEndPoint(address, port));
-
-  if (result == net::OK &&
-      socket_->GetLocalAddress(&bound_address_) != net::OK) {
-    SendBindACKError();
-    return;
-  }
-
-  OnBindCompleted(result);
-}
-
-void PepperUDPSocket::RecvFrom(int32_t num_bytes) {
-  if (recvfrom_buffer_.get()) {
-    SendRecvFromACKError();
-    return;
-  }
-
-  recvfrom_buffer_ = new net::IOBuffer(num_bytes);
-  int result = socket_->RecvFrom(
-      recvfrom_buffer_, num_bytes, &recvfrom_address_,
-      base::Bind(&PepperUDPSocket::OnRecvFromCompleted,
-                 base::Unretained(this)));
-
-  if (result != net::ERR_IO_PENDING)
-    OnRecvFromCompleted(result);
-}
-
-void PepperUDPSocket::SendTo(const std::string& data,
-                             const PP_NetAddress_Private& addr) {
-  if (sendto_buffer_.get() || data.empty()) {
-    SendSendToACKError();
-    return;
-  }
-
-  net::IPAddressNumber address;
-  int port;
-  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
-    SendSendToACKError();
-    return;
-  }
-
-  int data_size = data.size();
-
-  sendto_buffer_ = new net::IOBuffer(data_size);
-  memcpy(sendto_buffer_->data(), data.data(), data_size);
-  int result = socket_->SendTo(
-      sendto_buffer_, data_size, net::IPEndPoint(address, port),
-      base::Bind(&PepperUDPSocket::OnSendToCompleted, base::Unretained(this)));
-
-  if (result != net::ERR_IO_PENDING)
-    OnSendToCompleted(result);
-}
-
-void PepperUDPSocket::SendRecvFromACKError() {
-  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
+void PepperUDPSocket::SendRecvFromReply(bool succeeded,
+                                        const std::string& data,
+                                        const PP_NetAddress_Private& addr) {
   manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string(),
-      addr));
-}
-
-void PepperUDPSocket::SendSendToACKError() {
-  manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
-}
-
-void PepperUDPSocket::SendBindACKError() {
-  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
-  manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, addr));
-}
-
-void PepperUDPSocket::OnBindCompleted(int result) {
-  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
-  if (result < 0 ||
-      !NetAddressPrivateImpl::IPEndPointToNetAddress(bound_address_.address(),
-                                                     bound_address_.port(),
-                                                     &addr)) {
-    SendBindACKError();
-  } else {
-    manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
-        routing_id_, plugin_dispatcher_id_, socket_id_, true, addr));
-  }
-}
-
-void PepperUDPSocket::OnRecvFromCompleted(int result) {
-  DCHECK(recvfrom_buffer_.get());
-
-  // Convert IPEndPoint we get back from RecvFrom to a PP_NetAddress_Private,
-  // to send back.
-  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
-  if (result < 0 ||
-      !NetAddressPrivateImpl::IPEndPointToNetAddress(
-          recvfrom_address_.address(),
-          recvfrom_address_.port(),
-          &addr)) {
-    SendRecvFromACKError();
-  } else {
-    manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
-        routing_id_, plugin_dispatcher_id_, socket_id_, true,
-        std::string(recvfrom_buffer_->data(), result), addr));
-  }
-
-  recvfrom_buffer_ = NULL;
-}
-
-void PepperUDPSocket::OnSendToCompleted(int result) {
-  DCHECK(sendto_buffer_.get());
-
-  if (result < 0) {
-    SendSendToACKError();
-  } else {
-    manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
-        routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
-  }
-
-  sendto_buffer_ = NULL;
+      routing_id_, plugin_dispatcher_id_, socket_id_, succeeded, data, addr));
 }
 
 }  // namespace content