PPB_UDPSocket_Private is switched to the new Pepper proxy.

content/browser/renderer_host/pepper/pepper_udp_socket_private_shared.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 "content/browser/renderer_host/pepper/pepper_udp_socket_private_shared.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/proxy/ppapi_messages.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
+#include "ppapi/c/private/ppb_udp_socket_private.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) {
-  DCHECK(manager);
+PepperUDPSocketPrivateShared::PepperUDPSocketPrivateShared()
+    : allow_address_reuse_(false),
+      allow_broadcast_(false),
+      closed_(false),
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
-PepperUDPSocket::~PepperUDPSocket() {
+PepperUDPSocketPrivateShared::~PepperUDPSocketPrivateShared() {
   // Make sure there are no further callbacks from socket_.
   if (socket_.get())
     socket_->Close();
 }
 
-void PepperUDPSocket::AllowAddressReuse(bool value) {
-  allow_address_reuse_ = value;
+void PepperUDPSocketPrivateShared::SetBoolSocketFeature(int32_t name,
+                                                        bool value) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!socket_.get());
+  DCHECK(!closed());
+
+  switch(static_cast<PP_UDPSocketFeature_Private>(name)) {
+    case PP_UDPSOCKETFEATURE_ADDRESS_REUSE:
+      allow_address_reuse_ = value;
+      break;
+    case PP_UDPSOCKETFEATURE_BROADCAST:
+      allow_broadcast_ = value;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
 }
 
-void PepperUDPSocket::AllowBroadcast(bool value) {
-  allow_broadcast_ = value;
-}
+void PepperUDPSocketPrivateShared::Bind(const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(!closed());
 
-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();
+    SendBindError();
     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();
+    SendBindError();
     return;
   }
 
   OnBindCompleted(result);
 }
 
-void PepperUDPSocket::RecvFrom(int32_t num_bytes) {
+void PepperUDPSocketPrivateShared::RecvFrom(int32_t num_bytes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(socket_.get());
+  DCHECK(!closed());
+
   if (recvfrom_buffer_.get()) {
-    SendRecvFromACKError();
+    SendRecvFromError();
     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)));
+      base::Bind(&PepperUDPSocketPrivateShared::OnRecvFromCompleted,
+                 weak_factory_.GetWeakPtr()));
 
   if (result != net::ERR_IO_PENDING)
     OnRecvFromCompleted(result);
 }
 
-void PepperUDPSocket::SendTo(const std::string& data,
+void PepperUDPSocketPrivateShared::SendTo(const std::string& data,
                              const PP_NetAddress_Private& addr) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK(socket_.get());
+  DCHECK(!closed());
+
   if (sendto_buffer_.get() || data.empty()) {
-    SendSendToACKError();
+    SendSendToError();
     return;
   }
 
   net::IPAddressNumber address;
   int port;
   if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
-    SendSendToACKError();
+    SendSendToError();
     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)));
+      base::Bind(&PepperUDPSocketPrivateShared::OnSendToCompleted,
+                 weak_factory_.GetWeakPtr()));
 
   if (result != net::ERR_IO_PENDING)
     OnSendToCompleted(result);
 }
 
-void PepperUDPSocket::SendRecvFromACKError() {
-  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
-  manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string(),
-      addr));
+void PepperUDPSocketPrivateShared::Close() {
+  if (socket_.get())
+    socket_->Close();
+  closed_ = true;
 }
 
-void PepperUDPSocket::SendSendToACKError() {
-  manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
+void PepperUDPSocketPrivateShared::SendBindError() {
+  PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
+  SendBindReply(false, addr);
 }
 
-void PepperUDPSocket::SendBindACKError() {
+void PepperUDPSocketPrivateShared::SendRecvFromError() {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
-  manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
-      routing_id_, plugin_dispatcher_id_, socket_id_, false, addr));
+  SendRecvFromReply(false, "", addr);
 }
 
-void PepperUDPSocket::OnBindCompleted(int result) {
+void PepperUDPSocketPrivateShared::SendSendToError() {
+  SendSendToReply(false, 0);
+}
+
+void PepperUDPSocketPrivateShared::OnBindCompleted(int result) {
   PP_NetAddress_Private addr = NetAddressPrivateImpl::kInvalidNetAddress;
   if (result < 0 ||
       !NetAddressPrivateImpl::IPEndPointToNetAddress(bound_address_.address(),
                                                      bound_address_.port(),
                                                      &addr)) {
-    SendBindACKError();
+    SendBindError();
   } else {
-    manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
-        routing_id_, plugin_dispatcher_id_, socket_id_, true, addr));
+    SendBindReply(true, addr);
   }
 }
 
-void PepperUDPSocket::OnRecvFromCompleted(int result) {
+void PepperUDPSocketPrivateShared::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();
+    SendRecvFromError();
   } else {
-    manager_->Send(new PpapiMsg_PPBUDPSocket_RecvFromACK(
-        routing_id_, plugin_dispatcher_id_, socket_id_, true,
-        std::string(recvfrom_buffer_->data(), result), addr));
+    SendRecvFromReply(true,
+                      std::string(recvfrom_buffer_->data(), result),
+                      addr);
   }
 
   recvfrom_buffer_ = NULL;
 }
 
-void PepperUDPSocket::OnSendToCompleted(int result) {
+void PepperUDPSocketPrivateShared::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));
-  }
+  if (result < 0)
+    SendSendToError();
+  else
+    SendSendToReply(true, result);
 
   sendto_buffer_ = NULL;
 }
 
 }  // namespace content