Added out-of-process support for server sockets.

ppapi/proxy/ppb_tcp_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_socket_private_proxy.h"
 
 #include <map>
 
 #include "base/logging.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/shared_impl/private/tcp_socket_private_impl.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/thunk.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 typedef std::map<uint32, TCPSocketPrivateImpl*> IDToSocketMap;
 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;
   virtual void SendConnectWithNetAddress(
       const PP_NetAddress_Private& addr) OVERRIDE;
   virtual void SendSSLHandshake(const std::string& server_name,
                                 uint16_t server_port) OVERRIDE;
   virtual void SendRead(int32_t bytes_to_read) OVERRIDE;
   virtual void SendWrite(const std::string& buffer) OVERRIDE;
   virtual void SendDisconnect() OVERRIDE;
 
  private:
   void SendToBrowser(IPC::Message* msg);
 
   DISALLOW_COPY_AND_ASSIGN(TCPSocket);
 };
 
 TCPSocket::TCPSocket(const HostResource& resource, uint32 socket_id)
     : 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());
   (*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();
 }
 
 void TCPSocket::SendConnect(const std::string& host, uint16_t port) {
   SendToBrowser(new PpapiHostMsg_PPBTCPSocket_Connect(
       API_ID_PPB_TCPSOCKET_PRIVATE, socket_id_, host, port));
 }
 
 void TCPSocket::SendConnectWithNetAddress(const PP_NetAddress_Private& addr) {
@@ skipping 49 matching lines @@
   PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser(
       new PpapiHostMsg_PPBTCPSocket_Create(
           API_ID_PPB_TCPSOCKET_PRIVATE, dispatcher->plugin_dispatcher_id(),
           &socket_id));
   if (socket_id == 0)
     return 0;
   return (new TCPSocket(HostResource::MakeInstanceOnly(instance),
                         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)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ConnectACK,
                         OnMsgConnectACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_SSLHandshakeACK,
                         OnMsgSSLHandshakeACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_ReadACK, OnMsgReadACK)
     IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPSocket_WriteACK, OnMsgWriteACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 56 matching lines @@
     return;
   }
   IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
   if (iter == g_id_to_socket->end())
     return;
   iter->second->OnWriteCompleted(succeeded, bytes_written);
 }
 
 }  // namespace proxy
 }  // namespace ppapi