Exposed Listen and Accept methods to plugin.

content/renderer/pepper_plugin_delegate_impl.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/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
-#include <queue>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util_proxy.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string_split.h"
@@ skipping 50 matching lines @@
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/glue/context_menu.h"
 #include "webkit/plugins/npapi/webplugin.h"
 #include "webkit/plugins/ppapi/file_path.h"
 #include "webkit/plugins/ppapi/ppb_file_io_impl.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_broker_impl.h"
 #include "webkit/plugins/ppapi/ppb_flash_impl.h"
 #include "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
+#include "webkit/plugins/ppapi/ppb_tcp_server_socket_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_tcp_socket_private_impl.h"
 #include "webkit/plugins/ppapi/ppb_udp_socket_private_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 #include "webkit/plugins/webplugininfo.h"
 
 using WebKit::WebView;
 using WebKit::WebFrame;
 
 namespace {
 
@@ skipping 1567 matching lines @@
   render_view_->Send(new PpapiHostMsg_PPBTCPSocket_Create(
       render_view_->routing_id(), 0, &socket_id));
   return socket_id;
 }
 
 void PepperPluginDelegateImpl::TCPSocketConnect(
     webkit::ppapi::PPB_TCPSocket_Private_Impl* socket,
     uint32 socket_id,
     const std::string& host,
     uint16_t port) {
-  tcp_sockets_.AddWithID(socket, socket_id);
+  RegisterTCPSocket(socket, socket_id);
   render_view_->Send(
       new PpapiHostMsg_PPBTCPSocket_Connect(socket_id, host, port));
 }
 
 void PepperPluginDelegateImpl::TCPSocketConnectWithNetAddress(
       webkit::ppapi::PPB_TCPSocket_Private_Impl* socket,
       uint32 socket_id,
       const PP_NetAddress_Private& addr) {
-  tcp_sockets_.AddWithID(socket, socket_id);
+  RegisterTCPSocket(socket, socket_id);
   render_view_->Send(
       new PpapiHostMsg_PPBTCPSocket_ConnectWithNetAddress(socket_id, addr));
 }
 
 void PepperPluginDelegateImpl::TCPSocketSSLHandshake(
     uint32 socket_id,
     const std::string& server_name,
     uint16_t server_port) {
   DCHECK(tcp_sockets_.Lookup(socket_id));
   render_view_->Send(new PpapiHostMsg_PPBTCPSocket_SSLHandshake(
@@ skipping 14 matching lines @@
 }
 
 void PepperPluginDelegateImpl::TCPSocketDisconnect(uint32 socket_id) {
   // There are no DCHECK(tcp_sockets_.Lookup(socket_id)) because it
   // can be called before
   // TCPSocketConnect/TCPSocketConnectWithNetAddress is called.
   render_view_->Send(new PpapiHostMsg_PPBTCPSocket_Disconnect(socket_id));
   tcp_sockets_.Remove(socket_id);
 }
 
+void PepperPluginDelegateImpl::RegisterTCPSocket(
+    webkit::ppapi::PPB_TCPSocket_Private_Impl* socket,
+    uint32 socket_id) {
+  tcp_sockets_.AddWithID(socket, socket_id);
+}
+
 uint32 PepperPluginDelegateImpl::UDPSocketCreate() {
   if (!CanUseSocketAPIs())
     return 0;
 
   uint32 socket_id = 0;
   render_view_->Send(new PpapiHostMsg_PPBUDPSocket_Create(
       render_view_->routing_id(), 0, &socket_id));
   return socket_id;
 }
 
@@ skipping 21 matching lines @@
       new PpapiHostMsg_PPBUDPSocket_SendTo(socket_id, buffer, net_addr));
 }
 
 void PepperPluginDelegateImpl::UDPSocketClose(uint32 socket_id) {
   // There are no DCHECK(udp_sockets_.Lookup(socket_id)) because it
   // can be called before UDPSocketBind is called.
   render_view_->Send(new PpapiHostMsg_PPBUDPSocket_Close(socket_id));
   udp_sockets_.Remove(socket_id);
 }
 
+bool PepperPluginDelegateImpl::TCPServerSocketInitialize(
+    webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket) {
+  DCHECK(socket != NULL);
+  if (!CanUseSocketAPIs())
+    return false;
+
+  uninitialized_tcp_server_sockets_.push_back(socket);
+  tcp_server_sockets_positions_[socket] =
+      --uninitialized_tcp_server_sockets_.end();
+  render_view_->Send(new PpapiHostMsg_PPBTCPServerSocket_Initialize(
+      render_view_->routing_id(), 0));
+  return true;
+}
+
+void PepperPluginDelegateImpl::TCPServerSocketListen(
+    webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket,
+    uint32 socket_id,
+    const PP_NetAddress_Private& addr,
+    int32_t backlog) {
+  tcp_server_sockets_.AddWithID(socket, socket_id);
+  render_view_->Send(
+      new PpapiHostMsg_PPBTCPServerSocket_Listen(socket_id, addr, backlog));
+}
+
+void PepperPluginDelegateImpl::TCPServerSocketAccept(uint32 socket_id) {
+  DCHECK(tcp_server_sockets_.Lookup(socket_id));
+  render_view_->Send(new PpapiHostMsg_PPBTCPServerSocket_Accept(socket_id));
+}
+
+void PepperPluginDelegateImpl::TCPServerSocketStopListening(uint32 socket_id) {
+  // There are no DCHECK(tcp_server_sockets_.Lookup(socket_id))
+  // because it can be called before TCPServerSocketListen is called.
+  render_view_->Send(
+      new PpapiHostMsg_PPBTCPServerSocket_StopListening(socket_id));
+  tcp_server_sockets_.Remove(socket_id);
+}
+
+void PepperPluginDelegateImpl::CancelInitializationOfTCPServerSocket(
+    webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket) {
+  TCPServerSocketMap::iterator it = tcp_server_sockets_positions_.find(socket);
+  DCHECK(it != tcp_server_sockets_positions_.end());
+
+  uninitialized_tcp_server_sockets_.erase(it->second);
+  tcp_server_sockets_positions_.erase(it);
+}
+
 int32_t PepperPluginDelegateImpl::ShowContextMenu(
     webkit::ppapi::PluginInstance* instance,
     webkit::ppapi::PPB_Flash_Menu_Impl* menu,
     const gfx::Point& position) {
   int32 render_widget_id = render_view_->routing_id();
   if (instance->FlashIsFullscreen(instance->pp_instance())) {
     webkit::ppapi::FullscreenContainer* container =
         instance->fullscreen_container();
     DCHECK(container);
     render_widget_id =
@@ skipping 210 matching lines @@
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
                         OnTCPSocketConnectACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                         OnTCPSocketSSLHandshakeACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnTCPSocketReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnTCPSocketWriteACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_BindACK, OnUDPSocketBindACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_RecvFromACK,
                         OnUDPSocketRecvFromACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBUDPSocket_SendToACK, OnUDPSocketSendToACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_InitializeACK,
+                        OnTCPServerSocketInitializeACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_ListenACK,
+                        OnTCPServerSocketListenACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_AcceptACK,
+                        OnTCPServerSocketAcceptACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PepperPluginDelegateImpl::OnDestruct() {
   // Nothing to do here. Default implementation in RenderViewObserver does
   // 'delete this' but it's not suitable for PepperPluginDelegateImpl because
   // it's non-pointer member in RenderViewImpl.
 }
 
 void PepperPluginDelegateImpl::OnTCPSocketConnectACK(
     uint32 plugin_dispatcher_id,
     uint32 socket_id,
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
   webkit::ppapi::PPB_TCPSocket_Private_Impl* socket =
       tcp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnConnectCompleted(succeeded, local_addr, remote_addr);
+  if (!succeeded)
+    tcp_sockets_.Remove(socket_id);
 }
 
 void PepperPluginDelegateImpl::OnTCPSocketSSLHandshakeACK(
     uint32 plugin_dispatcher_id,
     uint32 socket_id,
     bool succeeded) {
   webkit::ppapi::PPB_TCPSocket_Private_Impl* socket =
       tcp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnSSLHandshakeCompleted(succeeded);
@@ skipping 19 matching lines @@
     socket->OnWriteCompleted(succeeded, bytes_written);
 }
 
 void PepperPluginDelegateImpl::OnUDPSocketBindACK(uint32 plugin_dispatcher_id,
                                                   uint32 socket_id,
                                                   bool succeeded) {
   webkit::ppapi::PPB_UDPSocket_Private_Impl* socket =
       udp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnBindCompleted(succeeded);
+  if (!succeeded)
+    udp_sockets_.Remove(socket_id);
 }
 
 void PepperPluginDelegateImpl::OnUDPSocketRecvFromACK(
     uint32 plugin_dispatcher_id,
     uint32 socket_id,
     bool succeeded,
     const std::string& data,
     const PP_NetAddress_Private& remote_addr) {
   webkit::ppapi::PPB_UDPSocket_Private_Impl* socket =
       udp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnRecvFromCompleted(succeeded, data, remote_addr);
 }
 
 void PepperPluginDelegateImpl::OnUDPSocketSendToACK(uint32 plugin_dispatcher_id,
                                                     uint32 socket_id,
                                                     bool succeeded,
                                                     int32_t bytes_written) {
   webkit::ppapi::PPB_UDPSocket_Private_Impl* socket =
       udp_sockets_.Lookup(socket_id);
   if (socket)
     socket->OnSendToCompleted(succeeded, bytes_written);
 }
 
+void PepperPluginDelegateImpl::OnTCPServerSocketListenACK(
+    uint32 plugin_dispatcher_id,
+    uint32 socket_id,
+    bool succeeded) {
+  webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket =
+      tcp_server_sockets_.Lookup(socket_id);
+  if (socket)
+    socket->OnListenCompleted(succeeded);
+  if (!succeeded)
+    tcp_server_sockets_.Remove(socket_id);
+}
+
+void PepperPluginDelegateImpl::OnTCPServerSocketInitializeACK(
+    uint32 plugin_dispatcher_id,
+    uint32 tcp_server_socket_id) {
+  if (!uninitialized_tcp_server_sockets_.empty()) {
+    webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket =
+        uninitialized_tcp_server_sockets_.front();
+    uninitialized_tcp_server_sockets_.pop_front();
+    tcp_server_sockets_positions_.erase(socket);
+    DCHECK(socket != NULL);
+    socket->OnInitializeCompleted(tcp_server_socket_id);
+  } else {
+    render_view_->Send(
+        new PpapiHostMsg_PPBTCPServerSocket_Destroy(
+            tcp_server_socket_id));
+  }
+}
+
+void PepperPluginDelegateImpl::OnTCPServerSocketAcceptACK(
+    uint32 plugin_dispatcher_id,
+    uint32 tcp_server_socket_id,
+    uint32 tcp_socket_id,
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
+  webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket =
+      tcp_server_sockets_.Lookup(tcp_server_socket_id);
+  if (socket) {
+    bool succeeded = tcp_socket_id != 0;
+    socket->OnAcceptCompleted(succeeded,
+                              tcp_socket_id,
+                              local_addr,
+                              remote_addr);
+  }
+}
+
 int PepperPluginDelegateImpl::GetRoutingId() const {
   return render_view_->routing_id();
 }
 
 ContentGLContext*
 PepperPluginDelegateImpl::GetParentContextForPlatformContext3D() {
   WebGraphicsContext3DCommandBufferImpl* context =
       static_cast<WebGraphicsContext3DCommandBufferImpl*>(
           render_view_->webview()->graphicsContext3D());
   if (!context)
@@ skipping 31 matching lines @@
 void PepperPluginDelegateImpl::UnSetAndDeleteLockTargetAdapter(
     webkit::ppapi::PluginInstance* instance) {
   LockTargetMap::iterator it = mouse_lock_instances_.find(instance);
   if (it != mouse_lock_instances_.end()) {
     MouseLockDispatcher::LockTarget* target = it->second;
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(target);
     delete target;
     mouse_lock_instances_.erase(it);
   }
 }