Added out-of-process support for server sockets.

BUG=108277
TEST=OutOfProcessPPAPITest.TCPServerSocketPrivate


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

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

chrome/test/ui/ppapi_uitest.cc

@@ -477,6 +477,7 @@ TEST_PPAPI_NACL_VIA_HTTP_DISALLOWED_SOCKETS(TCPSocketPrivateDisallowed)
 TEST_PPAPI_NACL_VIA_HTTP_DISALLOWED_SOCKETS(UDPSocketPrivateDisallowed)
 
 TEST_PPAPI_IN_PROCESS_VIA_HTTP(TCPServerSocketPrivate)
+TEST_PPAPI_OUT_OF_PROCESS_VIA_HTTP(TCPServerSocketPrivate)
 // TODO(ygorshenin): http://crbug.com/116480.
 TEST_PPAPI_NACL_VIA_HTTP(DISABLED_TCPServerSocketPrivate)
 

content/browser/renderer_host/pepper_message_filter.cc

@@ -175,8 +175,8 @@ uint32 PepperMessageFilter::AddAcceptedTCPSocket(
   return tcp_socket_id;
 }
 
-void PepperMessageFilter::RemoveTCPServerSocket(uint32 real_socket_id) {
-  TCPServerSocketMap::iterator iter = tcp_server_sockets_.find(real_socket_id);
+void PepperMessageFilter::RemoveTCPServerSocket(uint32 socket_id) {
+  TCPServerSocketMap::iterator iter = tcp_server_sockets_.find(socket_id);
   if (iter == tcp_server_sockets_.end()) {
     NOTREACHED();
     return;
@@ -567,7 +567,7 @@ void PepperMessageFilter::OnUDPClose(uint32 socket_id) {
 
 void PepperMessageFilter::OnTCPServerListen(int32 routing_id,
                                             uint32 plugin_dispatcher_id,
-                                            uint32 temp_socket_id,
+                                            PP_Resource socket_resource,
                                             const PP_NetAddress_Private& addr,
                                             int32_t backlog) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ -577,7 +577,7 @@ void PepperMessageFilter::OnTCPServerListen(int32 routing_id,
                                      CanUseSocketAPIs(routing_id),
                                      routing_id,
                                      plugin_dispatcher_id,
-                                     temp_socket_id,
+                                     socket_resource,
                                      addr,
                                      backlog));
 }
@@ -585,41 +585,42 @@ void PepperMessageFilter::OnTCPServerListen(int32 routing_id,
 void PepperMessageFilter::DoTCPServerListen(bool allowed,
                                             int32 routing_id,
                                             uint32 plugin_dispatcher_id,
-                                            uint32 temp_socket_id,
+                                            PP_Resource socket_resource,
                                             const PP_NetAddress_Private& addr,
                                             int32_t backlog) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!allowed) {
     Send(new PpapiMsg_PPBTCPServerSocket_ListenACK(routing_id,
                                                    plugin_dispatcher_id,
+                                                   socket_resource,
                                                    0,
-                                                   temp_socket_id,
                                                    PP_ERROR_FAILED));
     return;
   }
-  uint32 real_socket_id = GenerateSocketID();
-  if (real_socket_id == kInvalidSocketID) {
+  uint32 socket_id = GenerateSocketID();
+  if (socket_id == kInvalidSocketID) {
     Send(new PpapiMsg_PPBTCPServerSocket_ListenACK(routing_id,
                                                    plugin_dispatcher_id,
-                                                   real_socket_id,
-                                                   temp_socket_id,
+                                                   socket_resource,
+                                                   0,
                                                    PP_ERROR_NOSPACE));
     return;
   }
   PepperTCPServerSocket* socket = new PepperTCPServerSocket(
-      this, routing_id, plugin_dispatcher_id, real_socket_id, temp_socket_id);
-  tcp_server_sockets_[real_socket_id] =
-      linked_ptr<PepperTCPServerSocket>(socket);
+      this, routing_id, plugin_dispatcher_id, socket_resource, socket_id);
+  tcp_server_sockets_[socket_id] = linked_ptr<PepperTCPServerSocket>(socket);
   socket->Listen(addr, backlog);
 }
 
-void PepperMessageFilter::OnTCPServerAccept(uint32 real_socket_id) {
-  TCPServerSocketMap::iterator iter = tcp_server_sockets_.find(real_socket_id);
+void PepperMessageFilter::OnTCPServerAccept(int32 tcp_client_socket_routing_id,
+                                            uint32 server_socket_id) {
+  TCPServerSocketMap::iterator iter =
+      tcp_server_sockets_.find(server_socket_id);
   if (iter == tcp_server_sockets_.end()) {
     NOTREACHED();
     return;
   }
-  iter->second->Accept();
+  iter->second->Accept(tcp_client_socket_routing_id);
 }
 
 void PepperMessageFilter::OnHostResolverResolve(

content/browser/renderer_host/pepper_message_filter.h

@@ -17,6 +17,7 @@
 #include "content/public/browser/browser_message_filter.h"
 #include "net/base/ssl_config_service.h"
 #include "net/socket/stream_socket.h"
+#include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
 
 class ListValue;
@@ -82,7 +83,7 @@ class PepperMessageFilter : public content::BrowserMessageFilter {
   uint32 AddAcceptedTCPSocket(int32 routing_id,
                               uint32 plugin_dispatcher_id,
                               net::StreamSocket* socket);
-  void RemoveTCPServerSocket(uint32 real_socket_id);
+  void RemoveTCPServerSocket(uint32 socket_id);
 
   const net::SSLConfig& ssl_config() { return ssl_config_; }
 
@@ -160,10 +161,11 @@ class PepperMessageFilter : public content::BrowserMessageFilter {
 
   void OnTCPServerListen(int32 routing_id,
                          uint32 plugin_dispatcher_id,
-                         uint32 temp_socket_id,
+                         PP_Resource socket_resource,
                          const PP_NetAddress_Private& addr,
                          int32_t backlog);
-  void OnTCPServerAccept(uint32 real_socket_id);
+  void OnTCPServerAccept(int32 tcp_client_socket_routing_id,
+                         uint32 server_socket_id);
 
   void OnHostResolverResolve(int32 routing_id,
                              uint32 plugin_dispatcher_id,
@@ -195,7 +197,7 @@ class PepperMessageFilter : public content::BrowserMessageFilter {
   void DoTCPServerListen(bool allowed,
                          int32 routing_id,
                          uint32 plugin_dispatcher_id,
-                         uint32 temp_socket_id,
+                         PP_Resource socket_resource,
                          const PP_NetAddress_Private& addr,
                          int32_t backlog);
   void DoHostResolverResolve(bool allowed,

content/browser/renderer_host/pepper_tcp_server_socket.cc

@@ -24,13 +24,13 @@ PepperTCPServerSocket::PepperTCPServerSocket(
     PepperMessageFilter* manager,
     int32 routing_id,
     uint32 plugin_dispatcher_id,
-    uint32 real_socket_id,
-    uint32 temp_socket_id)
+    PP_Resource socket_resource,
+    uint32 socket_id)
     : manager_(manager),
       routing_id_(routing_id),
       plugin_dispatcher_id_(plugin_dispatcher_id),
-      real_socket_id_(real_socket_id),
-      temp_socket_id_(temp_socket_id),
+      socket_resource_(socket_resource),
+      socket_id_(socket_id),
       state_(BEFORE_LISTENING) {
   DCHECK(manager);
 }
@@ -57,7 +57,7 @@ void PepperTCPServerSocket::Listen(const PP_NetAddress_Private& addr,
     OnListenCompleted(result);
 }
 
-void PepperTCPServerSocket::Accept() {
+void PepperTCPServerSocket::Accept(int32 tcp_client_socket_routing_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (state_ != LISTENING) {
@@ -70,30 +70,31 @@ void PepperTCPServerSocket::Accept() {
   int result = socket_->Accept(
       &socket_buffer_,
       base::Bind(&PepperTCPServerSocket::OnAcceptCompleted,
-                 base::Unretained(this)));
+                 base::Unretained(this),
+                 tcp_client_socket_routing_id));
   if (result != net::ERR_IO_PENDING)
-    OnAcceptCompleted(result);
+    OnAcceptCompleted(tcp_client_socket_routing_id, result);
 }
 
 void PepperTCPServerSocket::CancelListenRequest() {
   manager_->Send(new PpapiMsg_PPBTCPServerSocket_ListenACK(
       routing_id_,
       plugin_dispatcher_id_,
+      socket_resource_,
       0,
-      temp_socket_id_,
       PP_ERROR_FAILED));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&PepperMessageFilter::RemoveTCPServerSocket, manager_,
-                 real_socket_id_));
+                 socket_id_));
 }
 
 void PepperTCPServerSocket::SendAcceptACKError() {
   manager_->Send(new PpapiMsg_PPBTCPServerSocket_AcceptACK(
       routing_id_,
       plugin_dispatcher_id_,
-      real_socket_id_,
+      socket_id_,
       0,
       NetAddressPrivateImpl::kInvalidNetAddress,
       NetAddressPrivateImpl::kInvalidNetAddress));
@@ -108,14 +109,16 @@ void PepperTCPServerSocket::OnListenCompleted(int result) {
     manager_->Send(new PpapiMsg_PPBTCPServerSocket_ListenACK(
         routing_id_,
         plugin_dispatcher_id_,
-        real_socket_id_,
-        temp_socket_id_,
+        socket_resource_,
+        socket_id_,
         PP_OK));
     state_ = LISTENING;
   }
 }
 
-void PepperTCPServerSocket::OnAcceptCompleted(int result) {
+void PepperTCPServerSocket::OnAcceptCompleted(
+    int32 tcp_client_socket_routing_id,
+    int result) {
   DCHECK(state_ == ACCEPT_IN_PROGRESS && socket_buffer_.get());
 
   if (result != net::OK) {
@@ -139,14 +142,14 @@ void PepperTCPServerSocket::OnAcceptCompleted(int result) {
       SendAcceptACKError();
     } else {
       uint32 accepted_socket_id =
-          manager_->AddAcceptedTCPSocket(routing_id_,
+          manager_->AddAcceptedTCPSocket(tcp_client_socket_routing_id,
                                          plugin_dispatcher_id_,
                                          socket.release());
       if (accepted_socket_id != 0) {
         manager_->Send(new PpapiMsg_PPBTCPServerSocket_AcceptACK(
             routing_id_,
             plugin_dispatcher_id_,
-            real_socket_id_,
+            socket_id_,
             accepted_socket_id,
             local_addr,
             remote_addr));

content/browser/renderer_host/pepper_tcp_server_socket.h

@@ -8,6 +8,7 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "ppapi/c/pp_resource.h"
 
 class PepperMessageFilter;
 struct PP_NetAddress_Private;
@@ -25,12 +26,12 @@ class PepperTCPServerSocket {
   PepperTCPServerSocket(PepperMessageFilter* manager,
                         int32 routing_id,
                         uint32 plugin_dispatcher_id,
-                        uint32 real_socket_id,
-                        uint32 temp_socket_id);
+                        PP_Resource socket_resource,
+                        uint32 socket_id);
   ~PepperTCPServerSocket();
 
   void Listen(const PP_NetAddress_Private& addr, int32 backlog);
-  void Accept();
+  void Accept(int32 tcp_client_socket_routing_id);
 
  private:
   enum State {
@@ -44,13 +45,17 @@ class PepperTCPServerSocket {
   void SendAcceptACKError();
 
   void OnListenCompleted(int result);
-  void OnAcceptCompleted(int result);
+  void OnAcceptCompleted(int32 tcp_client_socket_routing_id,
+                         int result);
 
   PepperMessageFilter* manager_;
   int32 routing_id_;
   uint32 plugin_dispatcher_id_;
-  uint32 real_socket_id_;
-  uint32 temp_socket_id_;
+  // socket_resource_ is used only as an ID on the browser side. So we
+  // don't hold the ref to this resource and it may become invalid at
+  // the renderer/plugin side.
+  PP_Resource socket_resource_;
+  uint32 socket_id_;
 
   State state_;
 

content/ppapi_plugin/ppapi_thread.cc

@@ -83,6 +83,10 @@ bool PpapiThread::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PpapiThread, msg)
     IPC_MESSAGE_HANDLER(PpapiMsg_LoadPlugin, OnMsgLoadPlugin)
     IPC_MESSAGE_HANDLER(PpapiMsg_CreateChannel, OnMsgCreateChannel)
+    IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBTCPServerSocket_ListenACK,
+                                OnPluginDispatcherMessageReceived(msg))
+    IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBTCPServerSocket_AcceptACK,
+                                OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBTCPSocket_ConnectACK,
                                 OnPluginDispatcherMessageReceived(msg))
     IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,

content/renderer/pepper/pepper_plugin_delegate_impl.cc

@@ -64,6 +64,8 @@
 #include "ppapi/shared_impl/platform_file.h"
 #include "ppapi/shared_impl/ppapi_preferences.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_tcp_server_socket_private_api.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileChooserCompletion.h"
@@ -1073,34 +1075,26 @@ void PepperPluginDelegateImpl::UDPSocketClose(uint32 socket_id) {
 }
 
 void PepperPluginDelegateImpl::TCPServerSocketListen(
-    webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket,
-    uint32 temp_socket_id,
+    PP_Resource socket_resource,
     const PP_NetAddress_Private& addr,
     int32_t backlog) {
-  uninitialized_tcp_server_sockets_.AddWithID(socket, temp_socket_id);
   render_view_->Send(
       new PpapiHostMsg_PPBTCPServerSocket_Listen(
-          render_view_->routing_id(), 0, temp_socket_id, addr, backlog));
+          render_view_->routing_id(), 0, socket_resource, addr, backlog));
 }
 
-void PepperPluginDelegateImpl::TCPServerSocketAccept(uint32 real_socket_id) {
-  DCHECK(tcp_server_sockets_.Lookup(real_socket_id));
+void PepperPluginDelegateImpl::TCPServerSocketAccept(uint32 server_socket_id) {
+  DCHECK(tcp_server_sockets_.Lookup(server_socket_id));
   render_view_->Send(new PpapiHostMsg_PPBTCPServerSocket_Accept(
-      real_socket_id));
+      render_view_->routing_id(), server_socket_id));
 }
 
 void PepperPluginDelegateImpl::TCPServerSocketStopListening(
-    uint32 real_socket_id,
-    uint32 temp_socket_id) {
-  if (real_socket_id == 0) {
-    if (uninitialized_tcp_server_sockets_.Lookup(temp_socket_id)) {
-      // Pending Listen request.
-      uninitialized_tcp_server_sockets_.Remove(temp_socket_id);
-    }
-  } else {
-    render_view_->Send(
-        new PpapiHostMsg_PPBTCPServerSocket_Destroy(real_socket_id));
-    tcp_server_sockets_.Remove(real_socket_id);
+    PP_Resource socket_resource,
+    uint32 socket_id) {
+  if (socket_id != 0) {
+    render_view_->Send(new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id));
+    tcp_server_sockets_.Remove(socket_id);
   }
 }
 
@@ -1517,38 +1511,40 @@ void PepperPluginDelegateImpl::OnUDPSocketSendToACK(uint32 plugin_dispatcher_id,
 
 void PepperPluginDelegateImpl::OnTCPServerSocketListenACK(
     uint32 plugin_dispatcher_id,
-    uint32 real_socket_id,
-    uint32 temp_socket_id,
+    PP_Resource socket_resource,
+    uint32 socket_id,
     int32_t status) {
-  webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket =
-      uninitialized_tcp_server_sockets_.Lookup(temp_socket_id);
-  if (socket == NULL) {
-    // StopListening was called before completion of Listen.
-    render_view_->Send(
-        new PpapiHostMsg_PPBTCPServerSocket_Destroy(real_socket_id));
-  } else {
-    uninitialized_tcp_server_sockets_.Remove(temp_socket_id);
-
+  ppapi::thunk::EnterResource<ppapi::thunk::PPB_TCPServerSocket_Private_API>
+      enter(socket_resource, true);
+  if (enter.succeeded()) {
+    ppapi::PPB_TCPServerSocket_Shared* socket =
+        static_cast<ppapi::PPB_TCPServerSocket_Shared*>(enter.object());
     if (status == PP_OK)
-      tcp_server_sockets_.AddWithID(socket, real_socket_id);
-    socket->OnListenCompleted(real_socket_id, status);
+      tcp_server_sockets_.AddWithID(socket, socket_id);
+    socket->OnListenCompleted(socket_id, status);
+  } else if (socket_id != 0 && status == PP_OK) {
+    // StopListening was called before completion of Listen.
+    render_view_->Send(new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id));
   }
 }
 
 void PepperPluginDelegateImpl::OnTCPServerSocketAcceptACK(
     uint32 plugin_dispatcher_id,
-    uint32 real_server_socket_id,
+    uint32 server_socket_id,
     uint32 accepted_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(real_server_socket_id);
+  ppapi::PPB_TCPServerSocket_Shared* socket =
+      tcp_server_sockets_.Lookup(server_socket_id);
   if (socket) {
-    bool succeeded = accepted_socket_id != 0;
+    bool succeeded = (accepted_socket_id != 0);
     socket->OnAcceptCompleted(succeeded,
                               accepted_socket_id,
                               local_addr,
                               remote_addr);
+  } else if (accepted_socket_id != 0) {
+    render_view_->Send(
+        new PpapiHostMsg_PPBTCPSocket_Disconnect(accepted_socket_id));
   }
 }
 

content/renderer/pepper/pepper_plugin_delegate_impl.h

@@ -21,6 +21,7 @@
 #include "content/renderer/mouse_lock_dispatcher.h"
 #include "content/renderer/pepper/pepper_parent_context_provider.h"
 #include "ppapi/shared_impl/private/ppb_host_resolver_shared.h"
+#include "ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h"
 #include "ppapi/shared_impl/private/tcp_socket_private_impl.h"
 #include "ppapi/shared_impl/private/udp_socket_private_impl.h"
 #include "ui/base/ime/text_input_type.h"
@@ -301,13 +302,13 @@ class PepperPluginDelegateImpl
                                const PP_NetAddress_Private& addr) OVERRIDE;
   virtual void UDPSocketClose(uint32 socket_id) OVERRIDE;
   virtual void TCPServerSocketListen(
-      webkit::ppapi::PPB_TCPServerSocket_Private_Impl* socket,
-      uint32 temp_socket_id,
+      PP_Resource socket_resource,
       const PP_NetAddress_Private& addr,
       int32_t backlog) OVERRIDE;
-  virtual void TCPServerSocketAccept(uint32 real_socket_id) OVERRIDE;
-  virtual void TCPServerSocketStopListening(uint32 real_socket_id,
-                                            uint32 temp_socket_id) OVERRIDE;
+  virtual void TCPServerSocketAccept(uint32 server_socket_id) OVERRIDE;
+  virtual void TCPServerSocketStopListening(
+      PP_Resource socket_resource,
+      uint32 socket_id) OVERRIDE;
 
   virtual void RegisterHostResolver(
       ppapi::PPB_HostResolver_Shared* host_resolver,
@@ -402,11 +403,11 @@ class PepperPluginDelegateImpl
                               const std::string& data,
                               const PP_NetAddress_Private& addr);
   void OnTCPServerSocketListenACK(uint32 plugin_dispatcher_id,
-                                  uint32 real_socket_id,
-                                  uint32 temp_socket_id,
+                                  PP_Resource socket_resource,
+                                  uint32 socket_id,
                                   int32_t status);
   void OnTCPServerSocketAcceptACK(uint32 plugin_dispatcher_id,
-                                  uint32 real_server_socket_id,
+                                  uint32 socket_id,
                                   uint32 accepted_socket_id,
                                   const PP_NetAddress_Private& local_addr,
                                   const PP_NetAddress_Private& remote_addr);
@@ -467,10 +468,7 @@ class PepperPluginDelegateImpl
 
   IDMap<webkit::ppapi::PPB_UDPSocket_Private_Impl> udp_sockets_;
 
-  IDMap<webkit::ppapi::PPB_TCPServerSocket_Private_Impl> tcp_server_sockets_;
-
-  IDMap<webkit::ppapi::PPB_TCPServerSocket_Private_Impl>
-      uninitialized_tcp_server_sockets_;
+  IDMap<ppapi::PPB_TCPServerSocket_Shared> tcp_server_sockets_;
 
   IDMap<ppapi::PPB_HostResolver_Shared> host_resolvers_;
 

ppapi/ppapi_proxy.gypi

@@ -107,6 +107,8 @@
         'proxy/ppb_message_loop_proxy.h',
         'proxy/ppb_pdf_proxy.cc',
         'proxy/ppb_pdf_proxy.h',
+        'proxy/ppb_tcp_server_socket_private_proxy.cc',
+        'proxy/ppb_tcp_server_socket_private_proxy.h',
         'proxy/ppb_tcp_socket_private_proxy.cc',
         'proxy/ppb_tcp_socket_private_proxy.h',
         'proxy/ppb_testing_proxy.cc',

ppapi/proxy/interface_list.cc

@@ -92,6 +92,7 @@
 #include "ppapi/proxy/ppb_instance_proxy.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 #include "ppapi/proxy/ppb_pdf_proxy.h"
+#include "ppapi/proxy/ppb_tcp_server_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_testing_proxy.h"
 #include "ppapi/proxy/ppb_text_input_proxy.h"

ppapi/proxy/ppapi_messages.h

@@ -351,6 +351,8 @@ IPC_MESSAGE_ROUTED4(PpapiMsg_PPBUDPSocket_SendToACK,
 
 // PPB_TCPServerSocket_Private.
 
+// |socket_resource| should not be used as Resource in browser. The
+// only purpose of this argument is to be echoed back.
 // |status| == PP_ERROR_NOSPACE means that the socket table is full
 // and new socket can't be initialized.
 // |status| == PP_ERROR_FAILED means that socket is correctly
@@ -359,12 +361,12 @@ IPC_MESSAGE_ROUTED4(PpapiMsg_PPBUDPSocket_SendToACK,
 // needed) and Listen call succeeds.
 IPC_MESSAGE_ROUTED4(PpapiMsg_PPBTCPServerSocket_ListenACK,
                     uint32 /* plugin_dispatcher_id */,
-                    uint32 /* real_socket_id */,
-                    uint32 /* temp_socket_id */,
+                    PP_Resource /* socket_resource */,
+                    uint32 /* socket_id */,
                     int32_t /* status */)
 IPC_MESSAGE_ROUTED5(PpapiMsg_PPBTCPServerSocket_AcceptACK,
                     uint32 /* plugin_dispatcher_id */,
-                    uint32 /* real_server_socket_id */,
+                    uint32 /* server_socket_id */,
                     uint32 /* accepted_socket_id */,
                     PP_NetAddress_Private /* local_addr */,
                     PP_NetAddress_Private /* remote_addr */)
@@ -1289,13 +1291,14 @@ IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBUDPSocket_Close,
 IPC_MESSAGE_CONTROL5(PpapiHostMsg_PPBTCPServerSocket_Listen,
                      int32 /* routing_id */,
                      uint32 /* plugin_dispatcher_id */,
-                     uint32 /* temp_socket_id */,
+                     PP_Resource /* socket_resource */,
                      PP_NetAddress_Private /* addr */,
                      int32_t /* backlog */)
-IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBTCPServerSocket_Accept,
-                     uint32 /* real_socket_id */)
+IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBTCPServerSocket_Accept,
+                     int32 /* tcp_client_socket_routing_id */,
+                     uint32 /* server_socket_id */)
 IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBTCPServerSocket_Destroy,
-                     uint32 /* real_socket_id */)
+                     uint32 /* socket_id */)
 
 // PPB_Font.
 IPC_SYNC_MESSAGE_CONTROL0_1(PpapiHostMsg_PPBFont_GetFontFamilies,

ppapi/proxy/ppb_tcp_server_socket_private_proxy.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 "ppapi/proxy/ppb_tcp_server_socket_private_proxy.h"
+
+#include <cstddef>
+
+#include "base/logging.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/plugin_globals.h"
+#include "ppapi/proxy/plugin_proxy_delegate.h"
+#include "ppapi/proxy/plugin_resource_tracker.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
+#include "ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h"
+#include "ppapi/shared_impl/resource.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/thunk.h"
+
+namespace ppapi {
+namespace proxy {
+
+typedef thunk::EnterResource<thunk::PPB_TCPServerSocket_Private_API>
+    EnterTCPServerSocket;
+
+namespace {
+
+class TCPServerSocket : public PPB_TCPServerSocket_Shared {
+ public:
+  TCPServerSocket(const HostResource& resource, uint32 plugin_dispatcher_id);
+  virtual ~TCPServerSocket();
+
+  virtual void OnAcceptCompleted(
+      bool succeeded,
+      uint32 tcp_socket_id,
+      const PP_NetAddress_Private& local_addr,
+      const PP_NetAddress_Private& remote_addr) OVERRIDE;
+
+  virtual void SendListen(const PP_NetAddress_Private& addr,
+                          int32_t backlog) OVERRIDE;
+  virtual void SendAccept() OVERRIDE;
+  virtual void SendStopListening() OVERRIDE;
+
+ private:
+  void SendToBrowser(IPC::Message* msg);
+
+  uint32 plugin_dispatcher_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(TCPServerSocket);
+};
+
+TCPServerSocket::TCPServerSocket(const HostResource& resource,
+                                 uint32 plugin_dispatcher_id)
+    : PPB_TCPServerSocket_Shared(resource),
+      plugin_dispatcher_id_(plugin_dispatcher_id) {
+}
+
+TCPServerSocket::~TCPServerSocket() {
+  StopListening();
+}
+
+void TCPServerSocket::OnAcceptCompleted(
+    bool succeeded,
+    uint32 accepted_socket_id,
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
+  if (!TrackedCallback::IsPending(accept_callback_) || !tcp_socket_buffer_) {
+    NOTREACHED();
+    return;
+  }
+
+  if (succeeded) {
+    *tcp_socket_buffer_ =
+        PPB_TCPSocket_Private_Proxy::CreateProxyResourceForConnectedSocket(
+            pp_instance(),
+            accepted_socket_id,
+            local_addr,
+            remote_addr);
+  }
+  tcp_socket_buffer_ = NULL;
+
+  TrackedCallback::ClearAndRun(&accept_callback_,
+                               succeeded ? PP_OK : PP_ERROR_FAILED);
+}
+
+void TCPServerSocket::SendListen(const PP_NetAddress_Private& addr,
+                                 int32_t backlog) {
+  SendToBrowser(new PpapiHostMsg_PPBTCPServerSocket_Listen(
+      API_ID_PPB_TCPSERVERSOCKET_PRIVATE,
+      plugin_dispatcher_id_,
+      pp_resource(),
+      addr,
+      backlog));
+}
+
+void TCPServerSocket::SendAccept() {
+  SendToBrowser(new PpapiHostMsg_PPBTCPServerSocket_Accept(
+      API_ID_PPB_TCPSOCKET_PRIVATE, socket_id_));
+}
+
+void TCPServerSocket::SendStopListening() {
+  if (socket_id_ != 0) {
+    SendToBrowser(new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id_));
+
+    PluginDispatcher* dispatcher =
+        PluginDispatcher::GetForInstance(host_resource().instance());
+    if (dispatcher) {
+      InterfaceProxy* proxy =
+          dispatcher->GetInterfaceProxy(API_ID_PPB_TCPSERVERSOCKET_PRIVATE);
+      PPB_TCPServerSocket_Private_Proxy* server_socket_proxy =
+          static_cast<PPB_TCPServerSocket_Private_Proxy*>(proxy);
+      server_socket_proxy->ObjectDestroyed(socket_id_);
+    }
+  }
+}
+
+void TCPServerSocket::SendToBrowser(IPC::Message* msg) {
+  PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(msg);
+}
+
+}  // namespace
+
+//------------------------------------------------------------------------------
+
+PPB_TCPServerSocket_Private_Proxy::PPB_TCPServerSocket_Private_Proxy(
+    Dispatcher* dispatcher)
+    : InterfaceProxy(dispatcher) {
+}
+
+PPB_TCPServerSocket_Private_Proxy::~PPB_TCPServerSocket_Private_Proxy() {
+}
+
+PP_Resource PPB_TCPServerSocket_Private_Proxy::CreateProxyResource(
+    PP_Instance instance) {
+  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
+  if (!dispatcher)
+    return 0;
+
+  TCPServerSocket* server_socket =
+      new TCPServerSocket(HostResource::MakeInstanceOnly(instance),
+                          dispatcher->plugin_dispatcher_id());
+  return server_socket->GetReference();
+}
+
+void PPB_TCPServerSocket_Private_Proxy::ObjectDestroyed(uint32 socket_id) {
+  id_to_server_socket_.erase(socket_id);
+}
+
+bool PPB_TCPServerSocket_Private_Proxy::OnMessageReceived(
+    const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PPB_TCPServerSocket_Private_Proxy, msg)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_ListenACK, OnMsgListenACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_AcceptACK, OnMsgAcceptACK)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PPB_TCPServerSocket_Private_Proxy::OnMsgListenACK(
+    uint32 plugin_dispatcher_id,
+    PP_Resource socket_resource,
+    uint32 socket_id,
+    int32_t status) {
+  EnterTCPServerSocket enter(socket_resource, true);
+  if (enter.succeeded()) {
+    PPB_TCPServerSocket_Shared* server_socket =
+        static_cast<PPB_TCPServerSocket_Shared*>(enter.object());
+    if (status == PP_OK)
+      id_to_server_socket_[socket_id] = server_socket;
+    server_socket->OnListenCompleted(socket_id, status);
+  } else if (socket_id != 0 && status == PP_OK) {
+    IPC::Message* msg =
+        new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id);
+    PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(msg);
+  }
+}
+
+void PPB_TCPServerSocket_Private_Proxy::OnMsgAcceptACK(
+    uint32 plugin_dispatcher_id,
+    uint32 server_socket_id,
+    uint32 accepted_socket_id,
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
+  IDToServerSocketMap::iterator it =
+      id_to_server_socket_.find(server_socket_id);
+  if (it != id_to_server_socket_.end()) {
+    bool succeeded = (accepted_socket_id != 0);
+    it->second->OnAcceptCompleted(succeeded,
+                                  accepted_socket_id,
+                                  local_addr,
+                                  remote_addr);
+  } else if (accepted_socket_id != 0) {
+    PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
+        new PpapiHostMsg_PPBTCPSocket_Disconnect(accepted_socket_id));
+  }
+}
+
+}  // namespace proxy
+}  // namespace ppapi

ppapi/proxy/ppb_tcp_server_socket_private_proxy.h

+// 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.
+
+#ifndef PPAPI_PROXY_PPB_TCP_SERVER_SOCKET_PRIVATE_PROXY_H_
+#define PPAPI_PROXY_PPB_TCP_SERVER_SOCKET_PRIVATE_PROXY_H_
+
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+#include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_resource.h"
+#include "ppapi/c/private/ppb_net_address_private.h"
+#include "ppapi/proxy/interface_proxy.h"
+
+namespace ppapi {
+
+class PPB_TCPServerSocket_Shared;
+
+namespace proxy {
+
+class PPB_TCPServerSocket_Private_Proxy : public InterfaceProxy {
+ public:
+  explicit PPB_TCPServerSocket_Private_Proxy(Dispatcher* dispatcher);
+  virtual ~PPB_TCPServerSocket_Private_Proxy();
+
+  static PP_Resource CreateProxyResource(PP_Instance instance);
+
+  void ObjectDestroyed(uint32 socket_id);
+
+  // InterfaceProxy implementation.
+  virtual bool OnMessageReceived(const IPC::Message& msg);
+
+  static const ApiID kApiID = API_ID_PPB_TCPSERVERSOCKET_PRIVATE;
+
+ private:
+  typedef std::map<uint32, PPB_TCPServerSocket_Shared*>
+    IDToServerSocketMap;
+
+  void OnMsgListenACK(uint32 plugin_dispatcher_id,
+                      PP_Resource socket_resource,
+                      uint32 socket_id,
+                      int32_t status);
+  void OnMsgAcceptACK(uint32 plugin_dispatcher_id,
+                      uint32 server_socket_id,
+                      uint32 accepted_socket_id,
+                      const PP_NetAddress_Private& local_addr,
+                      const PP_NetAddress_Private& remote_addr);
+
+  IDToServerSocketMap id_to_server_socket_;
+
+  DISALLOW_COPY_AND_ASSIGN(PPB_TCPServerSocket_Private_Proxy);
+};
+
+}  // namespace proxy
+}  // namespace ppapi
+
+#endif  // PPAPI_PROXY_PPB_TCP_SERVER_SOCKET_PRIVATE_PROXY_H_

ppapi/proxy/ppb_tcp_socket_private_proxy.cc

@@ -26,7 +26,13 @@ IDToSocketMap* g_id_to_socket = NULL;
 
 class TCPSocket : public TCPSocketPrivateImpl {
  public:
+  // C-tor for new sockets.
   TCPSocket(const HostResource& resource, uint32 socket_id);
+  // C-tor for already connected sockets.
+  TCPSocket(const HostResource& resource,
+            uint32 socket_id,
+            const PP_NetAddress_Private& local_addr,
+            const PP_NetAddress_Private& remote_addr);
   virtual ~TCPSocket();
 
   virtual void SendConnect(const std::string& host, uint16_t port) OVERRIDE;
@@ -52,6 +58,22 @@ TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id)
   (*g_id_to_socket)[socket_id] = this;
 }
 
+TCPSocket::TCPSocket(const HostResource& resource,
+                     uint32 socket_id,
+                     const PP_NetAddress_Private& local_addr,
+                     const PP_NetAddress_Private& remote_addr)
+    : TCPSocketPrivateImpl(resource, socket_id) {
+  if (!g_id_to_socket)
+    g_id_to_socket = new IDToSocketMap();
+  DCHECK(g_id_to_socket->find(socket_id) == g_id_to_socket->end());
+
+  connection_state_ = CONNECTED;
+  local_addr_ = local_addr;
+  remote_addr_ = remote_addr;
+
+  (*g_id_to_socket)[socket_id] = this;
+}
+
 TCPSocket::~TCPSocket() {
   Disconnect();
 }
@@ -121,6 +143,18 @@ PP_Resource PPB_TCPSocket_Private_Proxy::CreateProxyResource(
                         socket_id))->GetReference();
 }
 
+// static
+PP_Resource PPB_TCPSocket_Private_Proxy::CreateProxyResourceForConnectedSocket(
+    PP_Instance instance,
+    uint32 socket_id,
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
+  return (new TCPSocket(HostResource::MakeInstanceOnly(instance),
+                        socket_id,
+                        local_addr,
+                        remote_addr))->GetReference();
+}
+
 bool PPB_TCPSocket_Private_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_TCPSocket_Private_Proxy, msg)

ppapi/proxy/ppb_tcp_socket_private_proxy.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -23,6 +23,11 @@ class PPB_TCPSocket_Private_Proxy : public InterfaceProxy {
   virtual ~PPB_TCPSocket_Private_Proxy();
 
   static PP_Resource CreateProxyResource(PP_Instance instance);
+  static PP_Resource CreateProxyResourceForConnectedSocket(
+      PP_Instance instance,
+      uint32 socket_id,
+      const PP_NetAddress_Private& local_addr,
+      const PP_NetAddress_Private& remote_addr);
 
   // InterfaceProxy implementation.
   virtual bool OnMessageReceived(const IPC::Message& msg);

ppapi/proxy/resource_creation_proxy.cc

@@ -25,6 +25,7 @@
 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
 #include "ppapi/proxy/ppb_host_resolver_private_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
+#include "ppapi/proxy/ppb_tcp_server_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_tcp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_udp_socket_private_proxy.h"
 #include "ppapi/proxy/ppb_url_loader_proxy.h"
@@ -286,8 +287,7 @@ PP_Resource ResourceCreationProxy::CreateScrollbar(PP_Instance instance,
 #if !defined(OS_NACL)
 PP_Resource ResourceCreationProxy::CreateTCPServerSocketPrivate(
     PP_Instance instance) {
-  // TODO (ygorshenin): implement this
-  return 0;
+  return PPB_TCPServerSocket_Private_Proxy::CreateProxyResource(instance);
 }
 
 PP_Resource ResourceCreationProxy::CreateTCPSocketPrivate(

ppapi/shared_impl/api_id.h

@@ -41,6 +41,7 @@ enum ApiID {
   API_ID_PPB_OPENGLES2,
   API_ID_PPB_PDF,
   API_ID_PPB_SURFACE_3D,
+  API_ID_PPB_TCPSERVERSOCKET_PRIVATE,
   API_ID_PPB_TCPSOCKET_PRIVATE,
   API_ID_PPB_TESTING,
   API_ID_PPB_TEXT_INPUT,

ppapi/shared_impl/private/ppb_tcp_server_socket_shared.cc

@@ -13,8 +13,7 @@ namespace ppapi {
 
 PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(PP_Instance instance)
     : Resource(OBJECT_IS_IMPL, instance),
-      real_socket_id_(0),
-      temp_socket_id_(GenerateTempSocketID()),
+      socket_id_(0),
       state_(BEFORE_LISTENING),
       tcp_socket_buffer_(NULL) {
 }
@@ -22,8 +21,7 @@ PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(PP_Instance instance)
 PPB_TCPServerSocket_Shared::PPB_TCPServerSocket_Shared(
     const HostResource& resource)
     : Resource(OBJECT_IS_PROXY, resource),
-      real_socket_id_(0),
-      temp_socket_id_(GenerateTempSocketID()),
+      socket_id_(0),
       state_(BEFORE_LISTENING),
       tcp_socket_buffer_(NULL) {
 }
@@ -50,7 +48,7 @@ int32_t PPB_TCPServerSocket_Shared::Listen(const PP_NetAddress_Private* addr,
 
   listen_callback_ = new TrackedCallback(this, callback);
   // Send the request, the browser will call us back via ListenACK
-  SendListen(temp_socket_id_, *addr, backlog);
+  SendListen(*addr, backlog);
   return PP_OK_COMPLETIONPENDING;
 }
 
@@ -80,7 +78,7 @@ void PPB_TCPServerSocket_Shared::StopListening() {
   state_ = CLOSED;
 
   SendStopListening();
-  real_socket_id_ = 0;
+  socket_id_ = 0;
 
   if (listen_callback_.get())
     listen_callback_->PostAbort();
@@ -89,7 +87,7 @@ void PPB_TCPServerSocket_Shared::StopListening() {
   tcp_socket_buffer_ = NULL;
 }
 
-void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 real_socket_id,
+void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 socket_id,
                                                    int32_t status) {
   if (state_ != BEFORE_LISTENING ||
       !TrackedCallback::IsPending(listen_callback_)) {
@@ -98,16 +96,11 @@ void PPB_TCPServerSocket_Shared::OnListenCompleted(uint32 real_socket_id,
   }
 
   if (status == PP_OK) {
-    real_socket_id_ = real_socket_id;
+    socket_id_ = socket_id;
     state_ = LISTENING;
   }
 
   TrackedCallback::ClearAndRun(&listen_callback_, status);
 }
 
-uint32 PPB_TCPServerSocket_Shared::GenerateTempSocketID() {
-  static uint32 socket_id = 0;
-  return socket_id++;
-}
-
 }  // namespace ppapi

ppapi/shared_impl/private/ppb_tcp_server_socket_shared.h

@@ -40,16 +40,15 @@ class PPAPI_SHARED_EXPORT PPB_TCPServerSocket_Shared
                          PP_CompletionCallback callback) OVERRIDE;
   virtual void StopListening() OVERRIDE;
 
-  void OnListenCompleted(uint32 real_socket_id, int32_t status);
+  void OnListenCompleted(uint32 socket_id, int32_t status);
   virtual void OnAcceptCompleted(bool succeeded,
-                                 uint32 tcp_socket_id,
+                                 uint32 accepted_socket_id,
                                  const PP_NetAddress_Private& local_addr,
                                  const PP_NetAddress_Private& remote_addr) = 0;
 
   // Send functions that need to be implemented differently for the
   // proxied and non-proxied derived classes.
-  virtual void SendListen(uint32 temp_socket_id,
-                          const PP_NetAddress_Private& addr,
+  virtual void SendListen(const PP_NetAddress_Private& addr,
                           int32_t backlog) = 0;
   virtual void SendAccept() = 0;
   virtual void SendStopListening() = 0;
@@ -65,10 +64,7 @@ class PPAPI_SHARED_EXPORT PPB_TCPServerSocket_Shared
     CLOSED
   };
 
-  static uint32 GenerateTempSocketID();
-
-  uint32 real_socket_id_;
-  uint32 temp_socket_id_;
+  uint32 socket_id_;
   State state_;
 
   scoped_refptr<TrackedCallback> listen_callback_;

ppapi/thunk/interfaces_ppb_private.h

@@ -9,6 +9,7 @@
 
 PROXIED_API(PPB_Broker)
 PROXIED_API(PPB_HostResolver_Private)
+PROXIED_API(PPB_TCPServerSocket_Private)
 PROXIED_API(PPB_TCPSocket_Private)
 PROXIED_API(PPB_UDPSocket_Private)
 
@@ -31,6 +32,9 @@ PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE_0_1,
               PPB_NetAddress_Private_0_1)
 PROXIED_IFACE(NoAPIName, PPB_NETADDRESS_PRIVATE_INTERFACE_1_0,
               PPB_NetAddress_Private_1_0)
+PROXIED_IFACE(PPB_TCPServerSocket_Private,
+              PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE_0_1,
+              PPB_TCPServerSocket_Private_0_1)
 PROXIED_IFACE(PPB_TCPSocket_Private, PPB_TCPSOCKET_PRIVATE_INTERFACE_0_3,
               PPB_TCPSocket_Private_0_3)
 PROXIED_IFACE(PPB_UDPSocket_Private, PPB_UDPSOCKET_PRIVATE_INTERFACE_0_2,

webkit/plugins/ppapi/mock_plugin_delegate.cc

@@ -304,17 +304,17 @@ void MockPluginDelegate::UDPSocketClose(uint32 socket_id) {
 }
 
 void MockPluginDelegate::TCPServerSocketListen(
-    PPB_TCPServerSocket_Private_Impl* socket,
-    uint32 temp_socket_id,
+    PP_Resource socket_resource,
     const PP_NetAddress_Private& addr,
     int32_t backlog) {
 }
 
-void MockPluginDelegate::TCPServerSocketAccept(uint32 real_socket_id) {
+void MockPluginDelegate::TCPServerSocketAccept(uint32 server_socket_id) {
 }
 
-void MockPluginDelegate::TCPServerSocketStopListening(uint32 real_socket_id,
-                                                      uint32 temp_socket_id) {
+void MockPluginDelegate::TCPServerSocketStopListening(
+    PP_Resource socket_resource,
+    uint32 socket_id) {
 }
 
 void MockPluginDelegate::RegisterHostResolver(

webkit/plugins/ppapi/mock_plugin_delegate.h

@@ -136,13 +136,12 @@ class MockPluginDelegate : public PluginDelegate {
                                const std::string& buffer,
                                const PP_NetAddress_Private& addr);
   virtual void UDPSocketClose(uint32 socket_id);
-  virtual void TCPServerSocketListen(PPB_TCPServerSocket_Private_Impl* socket,
-                                     uint32 temp_socket_id,
+  virtual void TCPServerSocketListen(PP_Resource socket_resource,
                                      const PP_NetAddress_Private& addr,
                                      int32_t backlog);
-  virtual void TCPServerSocketAccept(uint32 real_socket_id);
-  virtual void TCPServerSocketStopListening(uint32 real_socket_id,
-                                            uint32 temp_socket_id);
+  virtual void TCPServerSocketAccept(uint32 server_socket_id);
+  virtual void TCPServerSocketStopListening(PP_Resource socket_resource,
+                                            uint32 socket_id);
   virtual void RegisterHostResolver(
       ::ppapi::PPB_HostResolver_Shared* host_resolver,
       uint32 host_resolver_id);

webkit/plugins/ppapi/plugin_delegate.h

@@ -23,6 +23,7 @@
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_instance.h"
+#include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ui/gfx/size.h"
 #include "webkit/fileapi/file_system_types.h"
@@ -88,7 +89,6 @@ class PluginModule;
 class PPB_Broker_Impl;
 class PPB_Flash_Menu_Impl;
 class PPB_Flash_NetConnector_Impl;
-class PPB_TCPServerSocket_Private_Impl;
 class PPB_TCPSocket_Private_Impl;
 class PPB_UDPSocket_Private_Impl;
 
@@ -481,13 +481,13 @@ class PluginDelegate {
   virtual void UDPSocketClose(uint32 socket_id) = 0;
 
   // For PPB_TCPServerSocket_Private.
-  virtual void TCPServerSocketListen(PPB_TCPServerSocket_Private_Impl* socket,
-                                     uint32 temp_socket_id,
+  virtual void TCPServerSocketListen(PP_Resource socket_resource,
                                      const PP_NetAddress_Private& addr,
                                      int32_t backlog) = 0;
-  virtual void TCPServerSocketAccept(uint32 real_socket_id) = 0;
-  virtual void TCPServerSocketStopListening(uint32 real_socket_id,
-                                            uint32 temp_socket_id) = 0;
+  virtual void TCPServerSocketAccept(uint32 server_socket_id) = 0;
+  virtual void TCPServerSocketStopListening(
+      PP_Resource socket_resource,
+      uint32 socket_id) = 0;
 
   // For PPB_HostResolver_Private.
   virtual void RegisterHostResolver(

webkit/plugins/ppapi/plugin_module.cc

@@ -79,7 +79,6 @@
 #include "ppapi/c/private/ppb_network_monitor_private.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
-#include "ppapi/c/private/ppb_tcp_server_socket_private.h"
 #include "ppapi/c/private/ppb_tcp_socket_private.h"
 #include "ppapi/c/private/ppb_udp_socket_private.h"
 #include "ppapi/c/private/ppb_uma_private.h"
@@ -359,8 +358,6 @@ const void* GetInterface(const char* name) {
     return ::ppapi::PPB_OpenGLES2_Shared::GetChromiumMapSubInterface();
   if (strcmp(name, PPB_PROXY_PRIVATE_INTERFACE) == 0)
     return PPB_Proxy_Impl::GetInterface();
-  if (strcmp(name, PPB_TCPSERVERSOCKET_PRIVATE_INTERFACE) == 0)
-    return ::ppapi::thunk::GetPPB_TCPServerSocket_Private_0_1_Thunk();
   if (strcmp(name, PPB_UMA_PRIVATE_INTERFACE) == 0)
     return PPB_UMA_Private_Impl::GetInterface();
   if (strcmp(name, PPB_URLLOADERTRUSTED_INTERFACE_0_3) == 0)

webkit/plugins/ppapi/ppb_tcp_server_socket_private_impl.cc

@@ -32,7 +32,7 @@ PP_Resource PPB_TCPServerSocket_Private_Impl::CreateResource(
 
 void PPB_TCPServerSocket_Private_Impl::OnAcceptCompleted(
     bool succeeded,
-    uint32 tcp_socket_id,
+    uint32 accepted_socket_id,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
   if (!::ppapi::TrackedCallback::IsPending(accept_callback_) ||
@@ -44,7 +44,7 @@ void PPB_TCPServerSocket_Private_Impl::OnAcceptCompleted(
   if (succeeded) {
     *tcp_socket_buffer_ =
         PPB_TCPSocket_Private_Impl::CreateConnectedSocket(pp_instance(),
-                                                          tcp_socket_id,
+                                                          accepted_socket_id,
                                                           local_addr,
                                                           remote_addr);
   }
@@ -55,14 +55,13 @@ void PPB_TCPServerSocket_Private_Impl::OnAcceptCompleted(
 }
 
 void PPB_TCPServerSocket_Private_Impl::SendListen(
-    uint32 temp_socket_id,
     const PP_NetAddress_Private& addr,
     int32_t backlog) {
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return;
 
-  plugin_delegate->TCPServerSocketListen(this, temp_socket_id, addr, backlog);
+  plugin_delegate->TCPServerSocketListen(pp_resource(), addr, backlog);
 }
 
 void PPB_TCPServerSocket_Private_Impl::SendAccept() {
@@ -70,7 +69,7 @@ void PPB_TCPServerSocket_Private_Impl::SendAccept() {
   if (!plugin_delegate)
     return;
 
-  plugin_delegate->TCPServerSocketAccept(real_socket_id_);
+  plugin_delegate->TCPServerSocketAccept(socket_id_);
 }
 
 void PPB_TCPServerSocket_Private_Impl::SendStopListening() {
@@ -78,8 +77,7 @@ void PPB_TCPServerSocket_Private_Impl::SendStopListening() {
   if (!plugin_delegate)
     return;
 
-  plugin_delegate->TCPServerSocketStopListening(real_socket_id_,
-                                                temp_socket_id_);
+  plugin_delegate->TCPServerSocketStopListening(pp_resource(), socket_id_);
 }
 
 }  // namespace ppapi

webkit/plugins/ppapi/ppb_tcp_server_socket_private_impl.h

@@ -18,12 +18,11 @@ class PPB_TCPServerSocket_Private_Impl
 
   virtual void OnAcceptCompleted(
       bool succeeded,
-      uint32 tcp_socket_id,
+      uint32 accepted_socket_id,
       const PP_NetAddress_Private& local_addr,
       const PP_NetAddress_Private& remote_addr) OVERRIDE;
 
-  virtual void SendListen(uint32_t temp_socket_id,
-                          const PP_NetAddress_Private& addr,
+  virtual void SendListen(const PP_NetAddress_Private& addr,
                           int32_t backlog) OVERRIDE;
   virtual void SendAccept() OVERRIDE;
   virtual void SendStopListening() OVERRIDE;