Re-land http://codereview.chromium.org/8586008/

Move PepperTCPSocket and PepperUDPSocket from pepper_message_filter to separate files

Comparing with 8586008, this change adds two more includes in pepper_message_filter if ENABLE_FLAPPER_HACKS is defined.

TBR=jam@chromium.org
BUG=None
TEST=OutOfProcessPPAPITest.TCPSocketPrivate passes.


Review URL: http://codereview.chromium.org/8664010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@111841 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 145 insertions, 0 deletions

diff --git a/content/browser/renderer_host/pepper_udp_socket.cc b/content/browser/renderer_host/pepper_udp_socket.cc
new file mode 100644
index 0000000..680625a
--- /dev/null
+++ b/content/browser/renderer_host/pepper_udp_socket.cc
@@ -0,0 +1,145 @@
+// Copyright (c) 2011 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_udp_socket.h"
+
+#include <string.h>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "content/browser/renderer_host/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/proxy/ppb_udp_socket_private_proxy.h"
+#include "ppapi/shared_impl/private/net_address_private_impl.h"
+
+using content::BrowserThread;
+using ppapi::NetAddressPrivateImpl;
+
+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_THIS_IN_INITIALIZER_LIST(
+          recvfrom_callback_(this, &PepperUDPSocket::OnRecvFromCompleted)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          sendto_callback_(this, &PepperUDPSocket::OnSendToCompleted)) {
+  DCHECK(manager);
+}
+
+PepperUDPSocket::~PepperUDPSocket() {
+  // Make sure there are no further callbacks from socket_.
+  if (socket_.get())
+    socket_->Close();
+}
+
+void PepperUDPSocket::Bind(const PP_NetAddress_Private& addr) {
+  socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
+
+  net::IPEndPoint address;
+  if (!socket_.get() ||
+      !NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address)) {
+    SendBindACK(false);
+    return;
+  }
+
+  int result = socket_->Listen(address);
+
+  SendBindACK(result == net::OK);
+}
+
+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_,
+                                 &recvfrom_callback_);
+
+  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::IPEndPoint address;
+  if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address)) {
+    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,
+                               address,
+                               &sendto_callback_);
+
+  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 PepperUDPSocket::SendSendToACKError() {
+  manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
+}
+
+void PepperUDPSocket::SendBindACK(bool result) {
+  manager_->Send(new PpapiMsg_PPBUDPSocket_BindACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, result));
+}
+
+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_,
+                                                     &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());
+
+  manager_->Send(new PpapiMsg_PPBUDPSocket_SendToACK(
+      routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
+
+  sendto_buffer_ = NULL;
+}