Revert 91150 - Define PPB_Flash_TCPSocket and PPB_Flash_SSLSocket.

TEST=None
BUG=None

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

TBR=yzshen@chromium.org
Review URL: http://codereview.chromium.org/7293001

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

33 files changed, 102 insertions, 1585 deletions

diff --git a/content/browser/renderer_host/pepper_message_filter.cc b/content/browser/renderer_host/pepper_message_filter.cc
index 55ec1f9..46d0095 100644
--- a/content/browser/renderer_host/pepper_message_filter.cc
+++ b/content/browser/renderer_host/pepper_message_filter.cc
@@ -4,17 +4,8 @@
 
 #include "content/browser/renderer_host/pepper_message_filter.h"
 
-#include <string.h>
-
-#include <limits>
-#include <string>
-
 #include "base/basictypes.h"
 #include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/memory/linked_ptr.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/threading/worker_pool.h"
 #include "base/values.h"
@@ -24,497 +15,40 @@
 #include "content/browser/resource_context.h"
 #include "content/common/pepper_messages.h"
 #include "net/base/address_list.h"
-#include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver.h"
-#include "net/base/io_buffer.h"
 #include "net/base/single_request_host_resolver.h"
-#include "net/base/sys_addrinfo.h"
-#include "net/socket/tcp_client_socket.h"
 #include "net/url_request/url_request_context.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
 #include "webkit/plugins/ppapi/ppb_flash_net_connector_impl.h"
 
 #if defined(ENABLE_FLAPPER_HACKS)
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
-#endif  // ENABLE_FLAPPER_HACKS
-
-namespace {
-
-bool ValidateNetAddress(const PP_Flash_NetAddress& addr) {
-  if (addr.size < sizeof(reinterpret_cast<sockaddr*>(0)->sa_family))
-    return false;
-
-  // TODO(viettrungluu): more careful validation?
-  // Just do a size check for AF_INET.
-  if (reinterpret_cast<const sockaddr*>(addr.data)->sa_family == AF_INET &&
-      addr.size >= sizeof(sockaddr_in))
-    return true;
-
-  // Ditto for AF_INET6.
-  if (reinterpret_cast<const sockaddr*>(addr.data)->sa_family == AF_INET6 &&
-      addr.size >= sizeof(sockaddr_in6))
-    return true;
-
-  // Reject everything else.
-  return false;
-}
-
-bool SockaddrToNetAddress(const sockaddr* sa,
-                          socklen_t sa_length,
-                          PP_Flash_NetAddress* net_addr) {
-  if (!sa || sa_length <= 0 || !net_addr)
-    return false;
-
-  CHECK_LE(static_cast<uint32_t>(sa_length), sizeof(net_addr->data));
-  net_addr->size = sa_length;
-  memcpy(net_addr->data, sa, net_addr->size);
-  return true;
-}
-
-bool IPEndPointToNetAddress(const net::IPEndPoint& ip,
-                            PP_Flash_NetAddress* net_addr) {
-  sockaddr_storage storage = { 0 };
-  size_t length = sizeof(storage);
-
-  return ip.ToSockAddr(reinterpret_cast<sockaddr*>(&storage), &length) &&
-         SockaddrToNetAddress(reinterpret_cast<const sockaddr*>(&storage),
-                              length, net_addr);
-}
-
-// Converts the first address to a PP_Flash_NetAddress.
-bool AddressListToNetAddress(const net::AddressList& address_list,
-                             PP_Flash_NetAddress* net_addr) {
-  const addrinfo* head = address_list.head();
-  return head &&
-         SockaddrToNetAddress(head->ai_addr, head->ai_addrlen, net_addr);
-}
-
-bool NetAddressToAddressList(const PP_Flash_NetAddress& net_addr,
-                             net::AddressList* address_list) {
-  if (!address_list || !ValidateNetAddress(net_addr))
-    return false;
-
-  net::IPEndPoint ip_end_point;
-  if (!ip_end_point.FromSockAddr(
-      reinterpret_cast<const sockaddr*>(net_addr.data), net_addr.size)) {
-    return false;
-  }
-  *address_list = net::AddressList::CreateFromIPAddress(ip_end_point.address(),
-                                                        ip_end_point.port());
-  return true;
-}
-
-}  // namespace
 
 // Make sure the storage in |PP_Flash_NetAddress| is big enough. (Do it here
 // since the data is opaque elsewhere.)
 COMPILE_ASSERT(sizeof(reinterpret_cast<PP_Flash_NetAddress*>(0)->data) >=
                sizeof(sockaddr_storage), PP_Flash_NetAddress_data_too_small);
+#endif  // ENABLE_FLAPPER_HACKS
 
 const PP_Flash_NetAddress kInvalidNetAddress = { 0 };
 
-class PepperMessageFilter::FlashTCPSocket {
- public:
-  FlashTCPSocket(PepperMessageFilter* pepper_message_filter,
-                 int32 routing_id,
-                 uint32 plugin_dispatcher_id,
-                 uint32 socket_id);
-  ~FlashTCPSocket();
-
-  void Connect(const std::string& host, uint16_t port);
-  void ConnectWithNetAddress(const PP_Flash_NetAddress& net_addr);
-  void Read(int32 bytes_to_read);
-  void Write(const std::string& data);
-
- private:
-  void StartConnect(const net::AddressList& addresses);
-
-  void SendConnectACKError();
-  void SendReadACKError();
-  void SendWriteACKError();
-
-  void OnResolveCompleted(int result);
-  void OnConnectCompleted(int result);
-  void OnReadCompleted(int result);
-  void OnWriteCompleted(int result);
-
-  PepperMessageFilter* pepper_message_filter_;
-  int32 routing_id_;
-  uint32 plugin_dispatcher_id_;
-  uint32 socket_id_;
-
-  bool connect_in_progress_;
-  bool connected_;
-  bool end_of_file_reached_;
-
-  net::CompletionCallbackImpl<FlashTCPSocket> resolve_callback_;
-  net::CompletionCallbackImpl<FlashTCPSocket> connect_callback_;
-  net::CompletionCallbackImpl<FlashTCPSocket> read_callback_;
-  net::CompletionCallbackImpl<FlashTCPSocket> write_callback_;
-
-  scoped_ptr<net::SingleRequestHostResolver> resolver_;
-  net::AddressList address_list_;
-
-  scoped_ptr<net::StreamSocket> socket_;
-
-  scoped_refptr<net::IOBuffer> read_buffer_;
-  scoped_refptr<net::IOBuffer> write_buffer_;
-
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
-};
-
-PepperMessageFilter::FlashTCPSocket::FlashTCPSocket(
-    PepperMessageFilter* pepper_message_filter,
-    int32 routing_id,
-    uint32 plugin_dispatcher_id,
-    uint32 socket_id)
-    : pepper_message_filter_(pepper_message_filter),
-      routing_id_(routing_id),
-      plugin_dispatcher_id_(plugin_dispatcher_id),
-      socket_id_(socket_id),
-      connect_in_progress_(false),
-      connected_(false),
-      end_of_file_reached_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          resolve_callback_(this, &FlashTCPSocket::OnResolveCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &FlashTCPSocket::OnConnectCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &FlashTCPSocket::OnReadCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &FlashTCPSocket::OnWriteCompleted)) {
-  DCHECK(pepper_message_filter);
-}
-
-PepperMessageFilter::FlashTCPSocket::~FlashTCPSocket() {
-  // Make sure no further callbacks from socket_.
-  if (socket_.get())
-    socket_->Disconnect();
-}
-
-void PepperMessageFilter::FlashTCPSocket::Connect(const std::string& host,
-                                                  uint16_t port) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (connect_in_progress_ || connected_) {
-    SendConnectACKError();
-    return;
-  }
-
-  connect_in_progress_ = true;
-  net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
-  resolver_.reset(new net::SingleRequestHostResolver(
-      pepper_message_filter_->GetHostResolver()));
-  int result = resolver_->Resolve(request_info, &address_list_,
-                                  &resolve_callback_, net::BoundNetLog());
-  if (result != net::ERR_IO_PENDING)
-    OnResolveCompleted(result);
-}
-
-void PepperMessageFilter::FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress& net_addr) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (connect_in_progress_ || connected_ ||
-      !NetAddressToAddressList(net_addr, &address_list_)) {
-    SendConnectACKError();
-    return;
-  }
-
-  connect_in_progress_ = true;
-  StartConnect(address_list_);
-}
-
-void PepperMessageFilter::FlashTCPSocket::Read(int32 bytes_to_read) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (!connected_ || end_of_file_reached_ || read_buffer_.get() ||
-      bytes_to_read <= 0) {
-    SendReadACKError();
-    return;
-  }
-
-  if (bytes_to_read > pp::proxy::kFlashTCPSocketMaxReadSize) {
-    NOTREACHED();
-    bytes_to_read = pp::proxy::kFlashTCPSocketMaxReadSize;
-  }
-
-  read_buffer_ = new net::IOBuffer(bytes_to_read);
-  int result = socket_->Read(read_buffer_, bytes_to_read, &read_callback_);
-  if (result != net::ERR_IO_PENDING)
-    OnReadCompleted(result);
-}
-
-void PepperMessageFilter::FlashTCPSocket::Write(const std::string& data) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (!connected_ || write_buffer_.get() || data.empty()) {
-    SendWriteACKError();
-    return;
-  }
-
-  int data_size = data.size();
-  if (data_size > pp::proxy::kFlashTCPSocketMaxWriteSize) {
-    NOTREACHED();
-    data_size = pp::proxy::kFlashTCPSocketMaxWriteSize;
-  }
-
-  write_buffer_ = new net::IOBuffer(data_size);
-  memcpy(write_buffer_->data(), data.c_str(), data_size);
-  int result = socket_->Write(write_buffer_, data.size(), &write_callback_);
-  if (result != net::ERR_IO_PENDING)
-    OnWriteCompleted(result);
-}
-
-void PepperMessageFilter::FlashTCPSocket::StartConnect(
-    const net::AddressList& addresses) {
-  DCHECK(connect_in_progress_);
-
-  socket_.reset(
-      new net::TCPClientSocket(addresses, NULL, net::NetLog::Source()));
-  int result = socket_->Connect(&connect_callback_);
-  if (result != net::ERR_IO_PENDING)
-    OnConnectCompleted(result);
-}
-
-void PepperMessageFilter::FlashTCPSocket::SendConnectACKError() {
-  pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashTCPSocket_ConnectACK(
-          routing_id_, plugin_dispatcher_id_, socket_id_, false,
-          kInvalidNetAddress, kInvalidNetAddress));
-}
-
-void PepperMessageFilter::FlashTCPSocket::SendReadACKError() {
-  pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashTCPSocket_ReadACK(
-          routing_id_, plugin_dispatcher_id_, socket_id_, false,
-          std::string()));
-}
-
-void PepperMessageFilter::FlashTCPSocket::SendWriteACKError() {
-  pepper_message_filter_->Send(
-      new PpapiMsg_PPBFlashTCPSocket_WriteACK(
-          routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
-}
-
-void PepperMessageFilter::FlashTCPSocket::OnResolveCompleted(int result) {
-  DCHECK(connect_in_progress_);
-
-  if (result != net::OK) {
-    SendConnectACKError();
-    connect_in_progress_ = false;
-    return;
-  }
-
-  StartConnect(address_list_);
-}
-
-void PepperMessageFilter::FlashTCPSocket::OnConnectCompleted(int result) {
-  DCHECK(connect_in_progress_ && socket_.get());
-
-  if (result != net::OK) {
-    SendConnectACKError();
-  } else {
-    net::IPEndPoint ip_end_point;
-    net::AddressList address_list;
-    PP_Flash_NetAddress local_addr = kInvalidNetAddress;
-    PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
-
-    if (socket_->GetLocalAddress(&ip_end_point) != net::OK ||
-        !IPEndPointToNetAddress(ip_end_point, &local_addr) ||
-        socket_->GetPeerAddress(&address_list) != net::OK ||
-        !AddressListToNetAddress(address_list, &remote_addr)) {
-      SendConnectACKError();
-    } else {
-      pepper_message_filter_->Send(
-          new PpapiMsg_PPBFlashTCPSocket_ConnectACK(
-              routing_id_, plugin_dispatcher_id_, socket_id_, true,
-              local_addr, remote_addr));
-      connected_ = true;
-    }
-  }
-  connect_in_progress_ = false;
-}
-
-void PepperMessageFilter::FlashTCPSocket::OnReadCompleted(int result) {
-  DCHECK(read_buffer_.get());
-
-  if (result > 0) {
-    pepper_message_filter_->Send(
-        new PpapiMsg_PPBFlashTCPSocket_ReadACK(
-            routing_id_, plugin_dispatcher_id_, socket_id_, true,
-            std::string(read_buffer_->data(), result)));
-  } else if (result == 0) {
-    end_of_file_reached_ = true;
-    pepper_message_filter_->Send(
-        new PpapiMsg_PPBFlashTCPSocket_ReadACK(
-            routing_id_, plugin_dispatcher_id_, socket_id_, true,
-            std::string()));
-  } else {
-    SendReadACKError();
-  }
-  read_buffer_ = NULL;
-}
-
-void PepperMessageFilter::FlashTCPSocket::OnWriteCompleted(int result) {
-  DCHECK(write_buffer_.get());
-
-  if (result >= 0) {
-    pepper_message_filter_->Send(
-        new PpapiMsg_PPBFlashTCPSocket_WriteACK(
-            routing_id_, plugin_dispatcher_id_, socket_id_, true, result));
-  } else {
-    SendWriteACKError();
-  }
-  write_buffer_ = NULL;
-}
-
-// FlashTCPSocketManager manages the mapping from socket IDs to FlashTCPSocket
-// instances.
-class PepperMessageFilter::FlashTCPSocketManager {
- public:
-  explicit FlashTCPSocketManager(PepperMessageFilter* pepper_message_filter);
-
-  void OnMsgCreate(int32 routing_id,
-                   uint32 plugin_dispatcher_id,
-                   uint32* socket_id);
-  void OnMsgConnect(uint32 socket_id,
-                    const std::string& host,
-                    uint16_t port);
-  void OnMsgConnectWithNetAddress(uint32 socket_id,
-                                  const PP_Flash_NetAddress& net_addr);
-  void OnMsgRead(uint32 socket_id, int32_t bytes_to_read);
-  void OnMsgWrite(uint32 socket_id, const std::string& data);
-  void OnMsgDisconnect(uint32 socket_id);
-
- private:
-  typedef std::map<uint32, linked_ptr<FlashTCPSocket> > SocketMap;
-  SocketMap sockets_;
-
-  uint32 next_socket_id_;
-
-  PepperMessageFilter* pepper_message_filter_;
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocketManager);
-};
-
-PepperMessageFilter::FlashTCPSocketManager::FlashTCPSocketManager(
-    PepperMessageFilter* pepper_message_filter)
-    : next_socket_id_(1),
-      pepper_message_filter_(pepper_message_filter) {
-  DCHECK(pepper_message_filter);
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgCreate(
-    int32 routing_id,
-    uint32 plugin_dispatcher_id,
-    uint32* socket_id) {
-  // Generate a socket ID. For each process which sends us socket requests, IDs
-  // of living sockets must be unique.
-  //
-  // However, it is safe to generate IDs based on the internal state of a single
-  // FlashTCPSocketManager object, because for each plugin or renderer process,
-  // there is at most one PepperMessageFilter (in other words, at most one
-  // FlashTCPSocketManager) talking to it.
-
-  DCHECK(socket_id);
-  if (sockets_.size() >= std::numeric_limits<uint32>::max()) {
-    // All valid IDs are being used.
-    *socket_id = 0;
-    return;
-  }
-  do {
-    // Although it is unlikely, make sure that we won't cause any trouble when
-    // the counter overflows.
-    *socket_id = next_socket_id_++;
-  } while (*socket_id == 0 ||
-           sockets_.find(*socket_id) != sockets_.end());
-  sockets_[*socket_id] = linked_ptr<FlashTCPSocket>(
-      new FlashTCPSocket(pepper_message_filter_, routing_id,
-                         plugin_dispatcher_id, *socket_id));
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnect(
-    uint32 socket_id,
-    const std::string& host,
-    uint16_t port) {
-  SocketMap::iterator iter = sockets_.find(socket_id);
-  if (iter == sockets_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  iter->second->Connect(host, port);
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgConnectWithNetAddress(
-    uint32 socket_id,
-    const PP_Flash_NetAddress& net_addr) {
-  SocketMap::iterator iter = sockets_.find(socket_id);
-  if (iter == sockets_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  iter->second->ConnectWithNetAddress(net_addr);
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgRead(
-    uint32 socket_id,
-    int32_t bytes_to_read) {
-  SocketMap::iterator iter = sockets_.find(socket_id);
-  if (iter == sockets_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  iter->second->Read(bytes_to_read);
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgWrite(
-    uint32 socket_id,
-    const std::string& data) {
-  SocketMap::iterator iter = sockets_.find(socket_id);
-  if (iter == sockets_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  iter->second->Write(data);
-}
-
-void PepperMessageFilter::FlashTCPSocketManager::OnMsgDisconnect(
-    uint32 socket_id) {
-  SocketMap::iterator iter = sockets_.find(socket_id);
-  if (iter == sockets_.end()) {
-    NOTREACHED();
-    return;
-  }
-
-  // Destroy the FlashTCPSocket instance will cancel any pending completion
-  // callback. From this point on, there won't be any messages associated with
-  // this socket sent to the plugin side.
-  sockets_.erase(iter);
-}
-
 PepperMessageFilter::PepperMessageFilter(
     const content::ResourceContext* resource_context)
     : resource_context_(resource_context),
-      host_resolver_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_(new FlashTCPSocketManager(this))) {
+      host_resolver_(NULL) {
   DCHECK(resource_context_);
 }
 
 PepperMessageFilter::PepperMessageFilter(net::HostResolver* host_resolver)
     : resource_context_(NULL),
-      host_resolver_(host_resolver),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_manager_(new FlashTCPSocketManager(this))) {
+      host_resolver_(host_resolver) {
   DCHECK(host_resolver);
 }
 
@@ -532,25 +66,6 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
                         OnGetLocalTimeZoneOffset)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(PpapiHostMsg_PPBFont_GetFontFamilies,
                                     OnGetFontFamilies)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Create,
-        socket_manager_.get(), FlashTCPSocketManager::OnMsgCreate)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Connect,
-        socket_manager_.get(), FlashTCPSocketManager::OnMsgConnect)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
-        socket_manager_.get(),
-        FlashTCPSocketManager::OnMsgConnectWithNetAddress)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Read,
-        socket_manager_.get(), FlashTCPSocketManager::OnMsgRead)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Write,
-        socket_manager_.get(), FlashTCPSocketManager::OnMsgWrite)
-    IPC_MESSAGE_FORWARD(
-        PpapiHostMsg_PPBFlashTCPSocket_Disconnect,
-        socket_manager_.get(), FlashTCPSocketManager::OnMsgDisconnect)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
@@ -560,6 +75,34 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg,
 
 namespace {
 
+bool ValidateNetAddress(const PP_Flash_NetAddress& addr) {
+  if (addr.size < sizeof(sa_family_t))
+    return false;
+
+  // TODO(viettrungluu): more careful validation?
+  // Just do a size check for AF_INET.
+  if (reinterpret_cast<const sockaddr*>(addr.data)->sa_family == AF_INET &&
+      addr.size >= sizeof(sockaddr_in))
+    return true;
+
+  // Ditto for AF_INET6.
+  if (reinterpret_cast<const sockaddr*>(addr.data)->sa_family == AF_INET6 &&
+      addr.size >= sizeof(sockaddr_in6))
+    return true;
+
+  // Reject everything else.
+  return false;
+}
+
+PP_Flash_NetAddress SockaddrToNetAddress(const struct sockaddr* sa,
+                                         socklen_t sa_length) {
+  PP_Flash_NetAddress addr;
+  CHECK_LE(sa_length, sizeof(addr.data));
+  addr.size = sa_length;
+  memcpy(addr.data, sa, addr.size);
+  return addr;
+}
+
 int ConnectTcpSocket(const PP_Flash_NetAddress& addr,
                      PP_Flash_NetAddress* local_addr_out,
                      PP_Flash_NetAddress* remote_addr_out) {
@@ -706,15 +249,14 @@ void PepperMessageFilter::ConnectTcpOnWorkerThread(int routing_id,
       IPC::InvalidPlatformFileForTransit();
   PP_Flash_NetAddress local_addr = kInvalidNetAddress;
   PP_Flash_NetAddress remote_addr = kInvalidNetAddress;
-  PP_Flash_NetAddress addr = kInvalidNetAddress;
 
   for (const struct addrinfo* ai = addresses.head(); ai; ai = ai->ai_next) {
-    if (SockaddrToNetAddress(ai->ai_addr, ai->ai_addrlen, &addr)) {
-      int fd = ConnectTcpSocket(addr, &local_addr, &remote_addr);
-      if (fd != -1) {
-        socket_for_transit = base::FileDescriptor(fd, true);
-        break;
-      }
+    PP_Flash_NetAddress addr = SockaddrToNetAddress(ai->ai_addr,
+                                                    ai->ai_addrlen);
+    int fd = ConnectTcpSocket(addr, &local_addr, &remote_addr);
+    if (fd != -1) {
+      socket_for_transit = base::FileDescriptor(fd, true);
+      break;
     }
   }
 
diff --git a/content/browser/renderer_host/pepper_message_filter.h b/content/browser/renderer_host/pepper_message_filter.h
index e9cd398..f047ec9 100644
--- a/content/browser/renderer_host/pepper_message_filter.h
+++ b/content/browser/renderer_host/pepper_message_filter.h
@@ -41,9 +41,6 @@ class PepperMessageFilter : public BrowserMessageFilter {
                                  bool* message_was_ok);
 
  private:
-  class FlashTCPSocket;
-  class FlashTCPSocketManager;
-
 #if defined(ENABLE_FLAPPER_HACKS)
   // Message handlers.
   void OnConnectTcp(int routing_id,
@@ -94,8 +91,6 @@ class PepperMessageFilter : public BrowserMessageFilter {
   // GetHostResolver instead of accessing directly.
   net::HostResolver* host_resolver_;
 
-  scoped_ptr<FlashTCPSocketManager> socket_manager_;
-
   DISALLOW_COPY_AND_ASSIGN(PepperMessageFilter);
 };
 
diff --git a/content/common/pepper_messages.cc b/content/common/pepper_messages.cc
index 4d7602b..b2a8f63 100644
--- a/content/common/pepper_messages.cc
+++ b/content/common/pepper_messages.cc
@@ -2,5 +2,40 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "ppapi/c/private/ppb_flash_net_connector.h"
+
 #define IPC_MESSAGE_IMPL
 #include "content/common/pepper_messages.h"
+
+namespace IPC {
+
+void ParamTraits<PP_Flash_NetAddress>::Write(Message* m, const param_type& p) {
+  WriteParam(m, p.size);
+  m->WriteBytes(p.data, static_cast<int>(p.size));
+}
+
+bool ParamTraits<PP_Flash_NetAddress>::Read(const Message* m,
+                                            void** iter,
+                                            param_type* p) {
+  uint16 size;
+  if (!ReadParam(m, iter, &size))
+    return false;
+  if (size > sizeof(p->data))
+    return false;
+  p->size = size;
+
+  const char* data;
+  if (!m->ReadBytes(iter, &data, size))
+    return false;
+  memcpy(p->data, data, size);
+  return true;
+}
+
+void ParamTraits<PP_Flash_NetAddress>::Log(const param_type& p,
+                                           std::string* l) {
+  l->append("<PP_Flash_NetAddress (");
+  LogParam(p.size, l);
+  l->append(" bytes)>");
+}
+
+}  // namespace IPC
diff --git a/content/common/pepper_messages.h b/content/common/pepper_messages.h
index b89705e..5a84626 100644
--- a/content/common/pepper_messages.h
+++ b/content/common/pepper_messages.h
@@ -4,9 +4,27 @@
 
 // Multiply-included message file, no traditional include guard
 #include "ipc/ipc_message_macros.h"
+#include "ipc/ipc_param_traits.h"
 #include "ipc/ipc_platform_file.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
-#include "ppapi/proxy/ppapi_param_traits.h"
+
+// Singly-included section, not yet converted.
+#ifndef CONTENT_COMMON_PEPPER_MESSAGES_H_
+#define CONTENT_COMMON_PEPPER_MESSAGES_H_
+
+namespace IPC {
+
+template <>
+struct ParamTraits<PP_Flash_NetAddress> {
+  typedef PP_Flash_NetAddress param_type;
+  static void Write(Message* m, const param_type& p);
+  static bool Read(const Message* m, void** iter, param_type* p);
+  static void Log(const param_type& p, std::string* l);
+};
+
+}  // namespace IPC
+
+#endif  // CONTENT_COMMON_PEPPER_MESSAGES_H_
 
 #define IPC_MESSAGE_START PepperMsgStart
 
diff --git a/content/ppapi_plugin/ppapi_thread.cc b/content/ppapi_plugin/ppapi_thread.cc
index c3b42ed..9b3c846 100644
--- a/content/ppapi_plugin/ppapi_thread.cc
+++ b/content/ppapi_plugin/ppapi_thread.cc
@@ -41,8 +41,7 @@ PpapiThread::PpapiThread(bool is_broker)
       get_plugin_interface_(NULL),
       connect_instance_func_(NULL),
       local_pp_module_(
-          base::RandInt(0, std::numeric_limits<PP_Module>::max())),
-      next_plugin_dispatcher_id_(1) {
+          base::RandInt(0, std::numeric_limits<PP_Module>::max())) {
 }
 
 PpapiThread::~PpapiThread() {
@@ -71,12 +70,6 @@ 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_PPBFlashTCPSocket_ConnectACK,
-                                OnPluginDispatcherMessageReceived(msg))
-    IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_ReadACK,
-                                OnPluginDispatcherMessageReceived(msg))
-    IPC_MESSAGE_HANDLER_GENERIC(PpapiMsg_PPBFlashTCPSocket_WriteACK,
-                                OnPluginDispatcherMessageReceived(msg))
   IPC_END_MESSAGE_MAP()
   return true;
 }
@@ -110,27 +103,6 @@ bool PpapiThread::SendToBrowser(IPC::Message* msg) {
   return Send(msg);
 }
 
-uint32 PpapiThread::Register(pp::proxy::PluginDispatcher* plugin_dispatcher) {
-  if (!plugin_dispatcher ||
-      plugin_dispatchers_.size() >= std::numeric_limits<uint32>::max()) {
-    return 0;
-  }
-
-  uint32 id = 0;
-  do {
-    // Although it is unlikely, make sure that we won't cause any trouble when
-    // the counter overflows.
-    id = next_plugin_dispatcher_id_++;
-  } while (id == 0 ||
-           plugin_dispatchers_.find(id) != plugin_dispatchers_.end());
-  plugin_dispatchers_[id] = plugin_dispatcher;
-  return id;
-}
-
-void PpapiThread::Unregister(uint32 plugin_dispatcher_id) {
-  plugin_dispatchers_.erase(plugin_dispatcher_id);
-}
-
 void PpapiThread::OnMsgLoadPlugin(const FilePath& path) {
   base::ScopedNativeLibrary library(base::LoadNativeLibrary(path, NULL));
 
@@ -220,20 +192,6 @@ void PpapiThread::OnMsgCreateChannel(base::ProcessHandle host_process_handle,
   Send(new PpapiHostMsg_ChannelCreated(channel_handle));
 }
 
-void PpapiThread::OnPluginDispatcherMessageReceived(const IPC::Message& msg) {
-  // The first parameter should be a plugin dispatcher ID.
-  void* iter = NULL;
-  uint32 id = 0;
-  if (!msg.ReadUInt32(&iter, &id)) {
-    NOTREACHED();
-    return;
-  }
-  std::map<uint32, pp::proxy::PluginDispatcher*>::iterator dispatcher =
-      plugin_dispatchers_.find(id);
-  if (dispatcher != plugin_dispatchers_.end())
-    dispatcher->second->OnMessageReceived(msg);
-}
-
 bool PpapiThread::SetupRendererChannel(base::ProcessHandle host_process_handle,
                                        int renderer_id,
                                        IPC::ChannelHandle* handle) {
diff --git a/content/ppapi_plugin/ppapi_thread.h b/content/ppapi_plugin/ppapi_thread.h
index 5b77f24..3d20387 100644
--- a/content/ppapi_plugin/ppapi_thread.h
+++ b/content/ppapi_plugin/ppapi_thread.h
@@ -6,8 +6,6 @@
 #define CONTENT_PPAPI_PLUGIN_PPAPI_THREAD_H_
 #pragma once
 
-#include <map>
-
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ -44,15 +42,11 @@ class PpapiThread : public ChildThread,
   virtual void PostToWebKitThread(const tracked_objects::Location& from_here,
                                   const base::Closure& task) OVERRIDE;
   virtual bool SendToBrowser(IPC::Message* msg) OVERRIDE;
-  virtual uint32 Register(
-      pp::proxy::PluginDispatcher* plugin_dispatcher) OVERRIDE;
-  virtual void Unregister(uint32 plugin_dispatcher_id) OVERRIDE;
 
   // Message handlers.
   void OnMsgLoadPlugin(const FilePath& path);
   void OnMsgCreateChannel(base::ProcessHandle host_process_handle,
                           int renderer_id);
-  void OnPluginDispatcherMessageReceived(const IPC::Message& msg);
 
   // Sets up the channel to the given renderer. On success, returns true and
   // fills the given ChannelHandle with the information from the new channel.
@@ -87,10 +81,6 @@ class PpapiThread : public ChildThread,
 
   scoped_ptr<PpapiWebKitThread> webkit_thread_;
 
-  // The PluginDispatcher instances contained in the map are not owned by it.
-  std::map<uint32, pp::proxy::PluginDispatcher*> plugin_dispatchers_;
-  uint32 next_plugin_dispatcher_id_;
-
   DISALLOW_IMPLICIT_CONSTRUCTORS(PpapiThread);
 };
 
diff --git a/ppapi/c/private/ppb_flash_net_connector.h b/ppapi/c/private/ppb_flash_net_connector.h
index 188dbef..2cc25bb 100644
--- a/ppapi/c/private/ppb_flash_net_connector.h
+++ b/ppapi/c/private/ppb_flash_net_connector.h
@@ -9,10 +9,15 @@
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/private/ppb_flash_file.h"  // For |PP_FileHandle|.
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 
 #define PPB_FLASH_NETCONNECTOR_INTERFACE "PPB_Flash_NetConnector;0.1"
 
+// This is an opaque type holding a network address.
+struct PP_Flash_NetAddress {
+  uint32_t size;
+  char data[128];
+};
+
 struct PPB_Flash_NetConnector {
   PP_Resource (*Create)(PP_Instance instance_id);
   PP_Bool (*IsFlashNetConnector)(PP_Resource resource_id);
diff --git a/ppapi/c/private/ppb_flash_tcp_socket.h b/ppapi/c/private/ppb_flash_tcp_socket.h
deleted file mode 100644
index 6577631..0000000
--- a/ppapi/c/private/ppb_flash_tcp_socket.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// 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.
-
-#ifndef PPAPI_C_PRIVATE_PPB_FLASH_TCP_SOCKET_H_
-#define PPAPI_C_PRIVATE_PPB_FLASH_TCP_SOCKET_H_
-
-#include "ppapi/c/pp_bool.h"
-#include "ppapi/c/pp_completion_callback.h"
-#include "ppapi/c/pp_instance.h"
-#include "ppapi/c/pp_resource.h"
-#include "ppapi/c/pp_stdint.h"
-
-// This is an opaque type holding a network address.
-struct PP_Flash_NetAddress {
-  uint32_t size;
-  char data[128];
-};
-
-#define PPB_FLASH_TCPSOCKET_INTERFACE "PPB_Flash_TCPSocket;0.1"
-
-struct PPB_Flash_TCPSocket {
-  PP_Resource (*Create)(PP_Instance instance);
-
-  PP_Bool (*IsFlashTCPSocket)(PP_Resource resource);
-
-  // Connects to a TCP port given as a host-port pair.
-  int32_t (*Connect)(PP_Resource tcp_socket,
-                     const char* host,
-                     uint16_t port,
-                     struct PP_CompletionCallback callback);
-
-  // Same as Connect(), but connecting to the address given by |addr|. A typical
-  // use-case would be for reconnections.
-  int32_t (*ConnectWithNetAddress)(PP_Resource tcp_socket,
-                                   const struct PP_Flash_NetAddress* addr,
-                                   struct PP_CompletionCallback callback);
-
-  // Gets the local address of the socket, if it has been connected.
-  // Returns PP_TRUE on success.
-  PP_Bool (*GetLocalAddress)(PP_Resource tcp_socket,
-                             struct PP_Flash_NetAddress* local_addr);
-
-  // Gets the remote address of the socket, if it has been connected.
-  // Returns PP_TRUE on success.
-  PP_Bool (*GetRemoteAddress)(PP_Resource tcp_socket,
-                              struct PP_Flash_NetAddress* remote_addr);
-
-  // Does SSL handshake and moves to sending and receiving encrypted data. The
-  // socket must have been successfully connected. |server_name| will be
-  // compared with the name(s) in the server's certificate during the SSL
-  // handshake.
-  int32_t (*InitiateSSL)(PP_Resource tcp_socket,
-                         const char* server_name,
-                         struct PP_CompletionCallback callback);
-
-  // Reads data from the socket. The size of |buffer| must be at least as large
-  // as |bytes_to_read|. May perform a partial read. Returns the number of bytes
-  // read or an error code. If the return value is 0, then it indicates that
-  // end-of-file was reached.
-  // This method won't return more than 1 megabyte, so if |bytes_to_read|
-  // exceeds 1 megabyte, it will always perform a partial read.
-  // Multiple outstanding read requests are not supported.
-  int32_t (*Read)(PP_Resource tcp_socket,
-                  char* buffer,
-                  int32_t bytes_to_read,
-                  struct PP_CompletionCallback callback);
-
-  // Writes data to the socket. May perform a partial write. Returns the number
-  // of bytes written or an error code.
-  // This method won't write more than 1 megabyte, so if |bytes_to_write|
-  // exceeds 1 megabyte, it will always perform a partial write.
-  // Multiple outstanding write requests are not supported.
-  int32_t (*Write)(PP_Resource tcp_socket,
-                   const char* buffer,
-                   int32_t bytes_to_write,
-                   struct PP_CompletionCallback callback);
-
-  // Cancels any IO that may be pending, and disconnects the socket. Any pending
-  // callbacks will still run, reporting PP_Error_Aborted if pending IO was
-  // interrupted. It is NOT valid to call Connect() again after a call to this
-  // method. Note: If the socket is destroyed when it is still connected, then
-  // it will be implicitly disconnected, so you are not required to call this
-  // method.
-  void (*Disconnect)(PP_Resource tcp_socket);
-};
-
-#endif  // PPAPI_C_PRIVATE_PPB_FLASH_TCP_SOCKET_H_
diff --git a/ppapi/cpp/private/flash_tcp_socket.cc b/ppapi/cpp/private/flash_tcp_socket.cc
deleted file mode 100644
index f5b4633..0000000
--- a/ppapi/cpp/private/flash_tcp_socket.cc
+++ /dev/null
@@ -1,102 +0,0 @@
-// 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.
-
-// TODO(yzshen): See the comment in corresponding .h file.
-
-#include "ppapi/cpp/private/flash_tcp_socket.h"
-
-#include "ppapi/c/pp_bool.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/cpp/completion_callback.h"
-#include "ppapi/cpp/instance.h"
-#include "ppapi/cpp/module.h"
-#include "ppapi/cpp/module_impl.h"
-
-namespace pp {
-
-namespace {
-
-template <> const char* interface_name<PPB_Flash_TCPSocket>() {
-  return PPB_FLASH_TCPSOCKET_INTERFACE;
-}
-
-}  // namespace
-
-namespace flash {
-
-TCPSocket::TCPSocket(Instance* instance) {
-  if (has_interface<PPB_Flash_TCPSocket>() && instance) {
-    PassRefFromConstructor(get_interface<PPB_Flash_TCPSocket>()->Create(
-        instance->pp_instance()));
-  }
-}
-
-int32_t TCPSocket::Connect(const char* host,
-                           uint16_t port,
-                           const CompletionCallback& callback) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_Flash_TCPSocket>()->Connect(
-      pp_resource(), host, port, callback.pp_completion_callback());
-}
-
-int32_t TCPSocket::ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
-                                         const CompletionCallback& callback) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_Flash_TCPSocket>()->ConnectWithNetAddress(
-      pp_resource(), addr, callback.pp_completion_callback());
-}
-
-bool TCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return false;
-
-  PP_Bool result = get_interface<PPB_Flash_TCPSocket>()->GetLocalAddress(
-      pp_resource(), local_addr);
-  return PP_ToBool(result);
-}
-
-bool TCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return false;
-  PP_Bool result = get_interface<PPB_Flash_TCPSocket>()->GetRemoteAddress(
-      pp_resource(), remote_addr);
-  return PP_ToBool(result);
-}
-
-int32_t TCPSocket::InitiateSSL(const char* server_name,
-                               const CompletionCallback& callback) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_Flash_TCPSocket>()->InitiateSSL(
-      pp_resource(), server_name, callback.pp_completion_callback());
-}
-
-int32_t TCPSocket::Read(char* buffer,
-                        int32_t bytes_to_read,
-                        const CompletionCallback& callback) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_Flash_TCPSocket>()->Read(
-      pp_resource(), buffer, bytes_to_read, callback.pp_completion_callback());
-}
-
-int32_t TCPSocket::Write(const char* buffer,
-                         int32_t bytes_to_write,
-                         const CompletionCallback& callback) {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return PP_ERROR_NOINTERFACE;
-  return get_interface<PPB_Flash_TCPSocket>()->Write(
-      pp_resource(), buffer, bytes_to_write, callback.pp_completion_callback());
-}
-
-void TCPSocket::Disconnect() {
-  if (!has_interface<PPB_Flash_TCPSocket>())
-    return;
-  return get_interface<PPB_Flash_TCPSocket>()->Disconnect(pp_resource());
-}
-
-}  // namespace flash
-}  // namespace pp
diff --git a/ppapi/cpp/private/flash_tcp_socket.h b/ppapi/cpp/private/flash_tcp_socket.h
deleted file mode 100644
index 8998728..0000000
--- a/ppapi/cpp/private/flash_tcp_socket.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// 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.
-
-// TODO(yzshen): This (and the .cc file) contain C++ wrappers for things
-// in ppapi/c/private/ppb_flash_tcp_socket.h. This is currently not used in
-// (or even compiled with) Chromium.
-
-#ifndef PPAPI_CPP_PRIVATE_FLASH_TCP_SOCKET_H_
-#define PPAPI_CPP_PRIVATE_FLASH_TCP_SOCKET_H_
-
-#include "ppapi/c/pp_stdint.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
-#include "ppapi/cpp/resource.h"
-
-namespace pp {
-
-class CompletionCallback;
-class Instance;
-
-namespace flash {
-
-class TCPSocket : public Resource {
- public:
-  explicit TCPSocket(Instance* instance);
-
-  int32_t Connect(const char* host,
-                  uint16_t port,
-                  const CompletionCallback& callback);
-  int32_t ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
-                                const CompletionCallback& callback);
-  bool GetLocalAddress(PP_Flash_NetAddress* local_addr);
-  bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr);
-  int32_t InitiateSSL(const char* server_name,
-                      const CompletionCallback& callback);
-  int32_t Read(char* buffer,
-               int32_t bytes_to_read,
-               const CompletionCallback& callback);
-  int32_t Write(const char* buffer,
-                int32_t bytes_to_write,
-                const CompletionCallback& callback);
-  void Disconnect();
-};
-
-}  // namespace flash
-}  // namespace pp
-
-#endif  // PPAPI_CPP_PRIVATE_FLASH_TCP_SOCKET_H_
diff --git a/ppapi/ppapi_cpp.gypi b/ppapi/ppapi_cpp.gypi
index 315e71c..045af8b 100644
--- a/ppapi/ppapi_cpp.gypi
+++ b/ppapi/ppapi_cpp.gypi
@@ -92,7 +92,6 @@
         'c/private/ppb_flash_file.h',
         'c/private/ppb_flash_menu.h',
         'c/private/ppb_flash_net_connector.h',
-        'c/private/ppb_flash_tcp_socket.h',
         'c/private/ppb_instance_private.h',
         'c/private/ppb_nacl_private.h',
         'c/private/ppb_pdf.h',
diff --git a/ppapi/ppapi_proxy.gypi b/ppapi/ppapi_proxy.gypi
index 5af875d..1d4ba98 100644
--- a/ppapi/ppapi_proxy.gypi
+++ b/ppapi/ppapi_proxy.gypi
@@ -90,8 +90,6 @@
         'proxy/ppb_flash_menu_proxy.h',
         'proxy/ppb_flash_net_connector_proxy.cc',
         'proxy/ppb_flash_net_connector_proxy.h',
-        'proxy/ppb_flash_tcp_socket_proxy.cc',
-        'proxy/ppb_flash_tcp_socket_proxy.h',
         'proxy/ppb_font_proxy.cc',
         'proxy/ppb_font_proxy.h',
         'proxy/ppb_graphics_2d_proxy.cc',
diff --git a/ppapi/ppapi_shared.gypi b/ppapi/ppapi_shared.gypi
index 9d0d734..11440a1 100644
--- a/ppapi/ppapi_shared.gypi
+++ b/ppapi/ppapi_shared.gypi
@@ -87,8 +87,6 @@
         'thunk/ppb_flash_menu_thunk.cc',
         'thunk/ppb_flash_net_connector_api.h',
         'thunk/ppb_flash_net_connector_thunk.cc',
-        'thunk/ppb_flash_tcp_socket_api.h',
-        'thunk/ppb_flash_tcp_socket_thunk.cc',
         'thunk/ppb_font_api.h',
         'thunk/ppb_font_thunk.cc',
         'thunk/ppb_fullscreen_thunk.cc',
diff --git a/ppapi/proxy/dispatcher.cc b/ppapi/proxy/dispatcher.cc
index b8db635..3520752 100644
--- a/ppapi/proxy/dispatcher.cc
+++ b/ppapi/proxy/dispatcher.cc
@@ -40,7 +40,6 @@
 #include "ppapi/c/private/ppb_flash_file.h"
 #include "ppapi/c/private/ppb_flash_menu.h"
 #include "ppapi/c/private/ppb_flash_net_connector.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/c/trusted/ppb_url_loader_trusted.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ -62,7 +61,6 @@
 #include "ppapi/proxy/ppb_flash_proxy.h"
 #include "ppapi/proxy/ppb_flash_menu_proxy.h"
 #include "ppapi/proxy/ppb_flash_net_connector_proxy.h"
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppb_graphics_2d_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
@@ -131,7 +129,6 @@ InterfaceList::InterfaceList() {
   AddPPB(PPB_Flash_File_ModuleLocal_Proxy::GetInfo());
   AddPPB(PPB_Flash_Proxy::GetInfo());
   AddPPB(PPB_Flash_Menu_Proxy::GetInfo());
-  AddPPB(PPB_Flash_TCPSocket_Proxy::GetInfo());
   AddPPB(PPB_Font_Proxy::GetInfo());
   AddPPB(PPB_Graphics2D_Proxy::GetInfo());
   AddPPB(PPB_ImageData_Proxy::GetInfo());
diff --git a/ppapi/proxy/interface_id.h b/ppapi/proxy/interface_id.h
index 8fccd1d..40554f5 100644
--- a/ppapi/proxy/interface_id.h
+++ b/ppapi/proxy/interface_id.h
@@ -33,7 +33,6 @@ enum InterfaceID {
   INTERFACE_ID_PPB_FLASH_FILE_MODULELOCAL,
   INTERFACE_ID_PPB_FLASH_MENU,
   INTERFACE_ID_PPB_FLASH_NETCONNECTOR,
-  INTERFACE_ID_PPB_FLASH_TCPSOCKET,
   INTERFACE_ID_PPB_FONT,
   INTERFACE_ID_PPB_GRAPHICS_2D,
   INTERFACE_ID_PPB_IMAGE_DATA,
diff --git a/ppapi/proxy/plugin_dispatcher.cc b/ppapi/proxy/plugin_dispatcher.cc
index 6e13b8f..ac0a072 100644
--- a/ppapi/proxy/plugin_dispatcher.cc
+++ b/ppapi/proxy/plugin_dispatcher.cc
@@ -44,8 +44,7 @@ PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
                                    GetInterfaceFunc get_interface)
     : Dispatcher(remote_process_handle, get_interface),
       plugin_delegate_(NULL),
-      received_preferences_(false),
-      plugin_dispatcher_id_(0) {
+      received_preferences_(false) {
   SetSerializationRules(new PluginVarSerializationRules);
 
   // As a plugin, we always support the PPP_Class interface. There's no
@@ -57,8 +56,6 @@ PluginDispatcher::PluginDispatcher(base::ProcessHandle remote_process_handle,
 }
 
 PluginDispatcher::~PluginDispatcher() {
-  if (plugin_delegate_)
-    plugin_delegate_->Unregister(plugin_dispatcher_id_);
 }
 
 // static
@@ -89,7 +86,6 @@ bool PluginDispatcher::InitPluginWithChannel(
   if (!Dispatcher::InitWithChannel(delegate, channel_handle, is_client))
     return false;
   plugin_delegate_ = delegate;
-  plugin_dispatcher_id_ = plugin_delegate_->Register(this);
 
   // The message filter will intercept and process certain messages directly
   // on the I/O thread.
diff --git a/ppapi/proxy/plugin_dispatcher.h b/ppapi/proxy/plugin_dispatcher.h
index ae6da60..1964d94 100644
--- a/ppapi/proxy/plugin_dispatcher.h
+++ b/ppapi/proxy/plugin_dispatcher.h
@@ -7,7 +7,6 @@
 
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process.h"
@@ -61,12 +60,6 @@ class PluginDispatcher : public Dispatcher {
     // Sends the given message to the browser. Identical semantics to
     // IPC::Message::Sender interface.
     virtual bool SendToBrowser(IPC::Message* msg) = 0;
-
-    // Registers the plugin dispatcher and returns an ID.
-    // Plugin dispatcher IDs will be used to dispatch messages from the browser.
-    // Each call to Register() has to be matched with a call to Unregister().
-    virtual uint32 Register(PluginDispatcher* plugin_dispatcher) = 0;
-    virtual void Unregister(uint32 plugin_dispatcher_id) = 0;
   };
 
   // Constructor for the plugin side. The init and shutdown functions will be
@@ -130,8 +123,6 @@ class PluginDispatcher : public Dispatcher {
   ppapi::FunctionGroupBase* GetFunctionAPI(
       pp::proxy::InterfaceID id);
 
-  uint32 plugin_dispatcher_id() const { return plugin_dispatcher_id_; }
-
  private:
   friend class PluginDispatcherTest;
 
@@ -163,8 +154,6 @@ class PluginDispatcher : public Dispatcher {
   bool received_preferences_;
   ppapi::Preferences preferences_;
 
-  uint32 plugin_dispatcher_id_;
-
   DISALLOW_COPY_AND_ASSIGN(PluginDispatcher);
 };
 
diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h
index 75f79ac..9b29993 100644
--- a/ppapi/proxy/ppapi_messages.h
+++ b/ppapi/proxy/ppapi_messages.h
@@ -26,7 +26,6 @@
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/pp_size.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 #include "ppapi/proxy/ppapi_param_traits.h"
 #include "ppapi/proxy/serialized_flash_menu.h"
 #include "ppapi/proxy/serialized_structs.h"
@@ -150,24 +149,6 @@ IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashNetConnector_ConnectACK,
                     std::string /* local_addr_as_string */,
                     std::string /* remote_addr_as_string */)
 
-// PPB_Flash_TCPSocket.
-IPC_MESSAGE_ROUTED5(PpapiMsg_PPBFlashTCPSocket_ConnectACK,
-                    uint32 /* plugin_dispatcher_id */,
-                    uint32 /* socket_id */,
-                    bool /* succeeded */,
-                    PP_Flash_NetAddress /* local_addr */,
-                    PP_Flash_NetAddress /* remote_addr */)
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashTCPSocket_ReadACK,
-                    uint32 /* plugin_dispatcher_id */,
-                    uint32 /* socket_id */,
-                    bool /* succeeded */,
-                    std::string /* data */)
-IPC_MESSAGE_ROUTED4(PpapiMsg_PPBFlashTCPSocket_WriteACK,
-                    uint32 /* plugin_dispatcher_id */,
-                    uint32 /* socket_id */,
-                    bool /* succeeded */,
-                    int32_t /* bytes_written */)
-
 // PPB_Graphics2D.
 IPC_MESSAGE_ROUTED2(PpapiMsg_PPBGraphics2D_FlushACK,
                     pp::proxy::HostResource /* graphics_2d */,
@@ -555,27 +536,6 @@ IPC_MESSAGE_ROUTED2(PpapiHostMsg_PPBFlashNetConnector_ConnectTcpAddress,
                     pp::proxy::HostResource /* connector */,
                     std::string /* net_address_as_string */)
 
-// PPB_Flash_TCPSocket.
-IPC_SYNC_MESSAGE_CONTROL2_1(PpapiHostMsg_PPBFlashTCPSocket_Create,
-                            int32 /* routing_id */,
-                            uint32 /* plugin_dispatcher_id */,
-                            uint32 /* socket_id */)
-IPC_MESSAGE_CONTROL3(PpapiHostMsg_PPBFlashTCPSocket_Connect,
-                     uint32 /* socket_id */,
-                     std::string /* host */,
-                     uint16_t /* port */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress,
-                     uint32 /* socket_id */,
-                     PP_Flash_NetAddress /* net_addr */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_Read,
-                     uint32 /* socket_id */,
-                     int32_t /* bytes_to_read */)
-IPC_MESSAGE_CONTROL2(PpapiHostMsg_PPBFlashTCPSocket_Write,
-                     uint32 /* socket_id */,
-                     std::string /* data */)
-IPC_MESSAGE_CONTROL1(PpapiHostMsg_PPBFlashTCPSocket_Disconnect,
-                     uint32 /* socket_id */)
-
 // PPB_Font.
 IPC_SYNC_MESSAGE_CONTROL0_1(PpapiHostMsg_PPBFont_GetFontFamilies,
                             std::string /* result */)
diff --git a/ppapi/proxy/ppapi_param_traits.cc b/ppapi/proxy/ppapi_param_traits.cc
index aa21dc1..20a00c8 100644
--- a/ppapi/proxy/ppapi_param_traits.cc
+++ b/ppapi/proxy/ppapi_param_traits.cc
@@ -8,7 +8,6 @@
 
 #include "ppapi/c/dev/pp_file_info_dev.h"
 #include "ppapi/c/pp_resource.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 #include "ppapi/proxy/host_resource.h"
 #include "ppapi/proxy/interface_proxy.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ -137,40 +136,6 @@ bool ParamTraits<PP_FileInfo_Dev>::Read(const Message* m, void** iter,
 void ParamTraits<PP_FileInfo_Dev>::Log(const param_type& p, std::string* l) {
 }
 
-// PP_Flash_NetAddress ---------------------------------------------------------
-
-// static
-void ParamTraits<PP_Flash_NetAddress>::Write(Message* m, const param_type& p) {
-  WriteParam(m, p.size);
-  m->WriteBytes(p.data, static_cast<int>(p.size));
-}
-
-// static
-bool ParamTraits<PP_Flash_NetAddress>::Read(const Message* m,
-                                            void** iter,
-                                            param_type* p) {
-  uint16 size;
-  if (!ReadParam(m, iter, &size))
-    return false;
-  if (size > sizeof(p->data))
-    return false;
-  p->size = size;
-
-  const char* data;
-  if (!m->ReadBytes(iter, &data, size))
-    return false;
-  memcpy(p->data, data, size);
-  return true;
-}
-
-// static
-void ParamTraits<PP_Flash_NetAddress>::Log(const param_type& p,
-                                           std::string* l) {
-  l->append("<PP_Flash_NetAddress (");
-  LogParam(p.size, l);
-  l->append(" bytes)>");
-}
-
 // PP_InputEvent ---------------------------------------------------------------
 
 // static
diff --git a/ppapi/proxy/ppapi_param_traits.h b/ppapi/proxy/ppapi_param_traits.h
index 62f807b..3d6d57f 100644
--- a/ppapi/proxy/ppapi_param_traits.h
+++ b/ppapi/proxy/ppapi_param_traits.h
@@ -15,7 +15,6 @@
 struct PP_FileInfo_Dev;
 struct PP_ObjectProperty;
 struct PP_Flash_Menu;
-struct PP_Flash_NetAddress;
 
 namespace pp {
 namespace proxy {
@@ -50,14 +49,6 @@ struct ParamTraits<PP_FileInfo_Dev> {
   static void Log(const param_type& p, std::string* l);
 };
 
-template <>
-struct ParamTraits<PP_Flash_NetAddress> {
-  typedef PP_Flash_NetAddress param_type;
-  static void Write(Message* m, const param_type& p);
-  static bool Read(const Message* m, void** iter, param_type* p);
-  static void Log(const param_type& p, std::string* l);
-};
-
 template<>
 struct ParamTraits<PP_InputEvent> {
   typedef PP_InputEvent param_type;
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc b/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
deleted file mode 100644
index d8968d8..0000000
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.cc
+++ /dev/null
@@ -1,438 +0,0 @@
-// 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 "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
-
-#include <algorithm>
-#include <cstring>
-#include <map>
-
-#include "base/logging.h"
-#include "base/memory/linked_ptr.h"
-#include "base/message_loop.h"
-#include "base/scoped_ptr.h"
-#include "base/task.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/proxy/plugin_dispatcher.h"
-#include "ppapi/proxy/plugin_resource.h"
-#include "ppapi/proxy/plugin_resource_tracker.h"
-#include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/thunk/ppb_flash_tcp_socket_api.h"
-#include "ppapi/thunk/thunk.h"
-
-using ppapi::thunk::PPB_Flash_TCPSocket_API;
-
-namespace pp {
-namespace proxy {
-
-const int32_t kFlashTCPSocketMaxReadSize = 1024 * 1024;
-const int32_t kFlashTCPSocketMaxWriteSize = 1024 * 1024;
-
-class FlashTCPSocket;
-
-namespace {
-
-typedef std::map<uint32, FlashTCPSocket*> IDToSocketMap;
-IDToSocketMap* g_id_to_socket = NULL;
-
-class AbortCallbackTask : public Task {
- public:
-  explicit AbortCallbackTask(PP_CompletionCallback callback)
-      : callback_(callback) {}
-  virtual ~AbortCallbackTask() {}
-  virtual void Run() {
-    if (callback_.func)
-      PP_RunCompletionCallback(&callback_, PP_ERROR_ABORTED);
-  }
-
- private:
-  PP_CompletionCallback callback_;
-};
-
-InterfaceProxy* CreateFlashTCPSocketProxy(Dispatcher* dispatcher,
-                                          const void* target_interface) {
-  return new PPB_Flash_TCPSocket_Proxy(dispatcher, target_interface);
-}
-
-}  // namespace
-
-class FlashTCPSocket : public PPB_Flash_TCPSocket_API,
-                       public PluginResource {
- public:
-  FlashTCPSocket(const HostResource& resource, uint32 socket_id);
-  virtual ~FlashTCPSocket();
-
-  // ResourceObjectBase overrides.
-  virtual PPB_Flash_TCPSocket_API* AsPPB_Flash_TCPSocket_API() OVERRIDE;
-
-  // PPB_Flash_TCPSocket_API implementation.
-  virtual int32_t Connect(const char* host,
-                          uint16_t port,
-                          PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t ConnectWithNetAddress(
-      const PP_Flash_NetAddress* addr,
-      PP_CompletionCallback callback) OVERRIDE;
-  virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) OVERRIDE;
-  virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) OVERRIDE;
-  virtual int32_t InitiateSSL(const char* server_name,
-                              PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Read(char* buffer,
-                       int32_t bytes_to_read,
-                       PP_CompletionCallback callback) OVERRIDE;
-  virtual int32_t Write(const char* buffer,
-                        int32_t bytes_to_write,
-                        PP_CompletionCallback callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-
-  // Notifications from the proxy.
-  void OnConnectCompleted(bool succeeded,
-                          const PP_Flash_NetAddress& local_addr,
-                          const PP_Flash_NetAddress& remote_addr);
-  void OnReadCompleted(bool succeeded, const std::string& data);
-  void OnWriteCompleted(bool succeeded, int32_t bytes_written);
-
- private:
-  enum ConnectionState {
-    // Before a connection is successfully established (including a connect
-    // request is pending or a previous connect request failed).
-    BEFORE_CONNECT,
-    CONNECTED,
-    DISCONNECTED
-  };
-
-  // Backend for both Connect() and ConnectWithNetAddress(). To keep things
-  // generic, the message is passed in (on error, it's deleted).
-  int32_t ConnectWithMessage(IPC::Message* msg,
-                             PP_CompletionCallback callback);
-
-  void PostAbortAndClearIfNecessary(PP_CompletionCallback* callback);
-
-  uint32 socket_id_;
-  ConnectionState connection_state_;
-
-  PP_CompletionCallback connect_callback_;
-  PP_CompletionCallback read_callback_;
-  PP_CompletionCallback write_callback_;
-
-  char* read_buffer_;
-  int32_t bytes_to_read_;
-
-  PP_Flash_NetAddress local_addr_;
-  PP_Flash_NetAddress remote_addr_;
-
-  DISALLOW_COPY_AND_ASSIGN(FlashTCPSocket);
-};
-
-FlashTCPSocket::FlashTCPSocket(const HostResource& resource, uint32 socket_id)
-    : PluginResource(resource),
-      socket_id_(socket_id),
-      connection_state_(BEFORE_CONNECT),
-      connect_callback_(PP_BlockUntilComplete()),
-      read_callback_(PP_BlockUntilComplete()),
-      write_callback_(PP_BlockUntilComplete()),
-      read_buffer_(NULL),
-      bytes_to_read_(-1) {
-  DCHECK(socket_id != 0);
-
-  local_addr_.size = 0;
-  memset(local_addr_.data, 0, sizeof(local_addr_.data));
-  remote_addr_.size = 0;
-  memset(remote_addr_.data, 0, sizeof(remote_addr_.data));
-
-  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;
-}
-
-FlashTCPSocket::~FlashTCPSocket() {
-  Disconnect();
-}
-
-PPB_Flash_TCPSocket_API* FlashTCPSocket::AsPPB_Flash_TCPSocket_API() {
-  return this;
-}
-
-int32_t FlashTCPSocket::Connect(const char* host,
-                                uint16_t port,
-                                PP_CompletionCallback callback) {
-  if (!host)
-    return PP_ERROR_BADARGUMENT;
-
-  return ConnectWithMessage(
-      new PpapiHostMsg_PPBFlashTCPSocket_Connect(socket_id_, host, port),
-      callback);
-}
-
-int32_t FlashTCPSocket::ConnectWithNetAddress(
-    const PP_Flash_NetAddress* addr,
-    PP_CompletionCallback callback) {
-  if (!addr)
-    return PP_ERROR_BADARGUMENT;
-
-  return ConnectWithMessage(
-      new PpapiHostMsg_PPBFlashTCPSocket_ConnectWithNetAddress(
-          socket_id_, *addr),
-      callback);
-}
-
-PP_Bool FlashTCPSocket::GetLocalAddress(PP_Flash_NetAddress* local_addr) {
-  if (connection_state_ != CONNECTED || !local_addr)
-    return PP_FALSE;
-
-  *local_addr = local_addr_;
-  return PP_TRUE;
-}
-
-PP_Bool FlashTCPSocket::GetRemoteAddress(PP_Flash_NetAddress* remote_addr) {
-  if (connection_state_ != CONNECTED || !remote_addr)
-    return PP_FALSE;
-
-  *remote_addr = remote_addr_;
-  return PP_TRUE;
-}
-
-int32_t FlashTCPSocket::InitiateSSL(const char* server_name,
-                                    PP_CompletionCallback callback) {
-  // TODO(yzshen): add it.
-  return PP_ERROR_FAILED;
-}
-
-int32_t FlashTCPSocket::Read(char* buffer,
-                             int32_t bytes_to_read,
-                             PP_CompletionCallback callback) {
-  if (!buffer || bytes_to_read <= 0 || !callback.func)
-    return PP_ERROR_BADARGUMENT;
-
-  if (connection_state_ != CONNECTED)
-    return PP_ERROR_FAILED;
-  if (read_callback_.func)
-    return PP_ERROR_INPROGRESS;
-
-  read_buffer_ = buffer;
-  bytes_to_read_ = std::min(bytes_to_read, kFlashTCPSocketMaxReadSize);
-  read_callback_ = callback;
-
-  // Send the request, the browser will call us back via ReadACK.
-  GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Read(socket_id_, bytes_to_read_));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-int32_t FlashTCPSocket::Write(const char* buffer,
-                              int32_t bytes_to_write,
-                              PP_CompletionCallback callback) {
-  if (!buffer || bytes_to_write <= 0 || !callback.func)
-    return PP_ERROR_BADARGUMENT;
-
-  if (connection_state_ != CONNECTED)
-    return PP_ERROR_FAILED;
-  if (write_callback_.func)
-    return PP_ERROR_INPROGRESS;
-
-  if (bytes_to_write > kFlashTCPSocketMaxWriteSize)
-    bytes_to_write = kFlashTCPSocketMaxWriteSize;
-
-  write_callback_ = callback;
-
-  // Send the request, the browser will call us back via WriteACK.
-  GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Write(
-          socket_id_, std::string(buffer, bytes_to_write)));
-  return PP_OK_COMPLETIONPENDING;
-}
-
-void FlashTCPSocket::Disconnect() {
-  if (connection_state_ == DISCONNECTED)
-    return;
-
-  connection_state_ = DISCONNECTED;
-  // After removed from the mapping, this object won't receive any notfications
-  // from the proxy.
-  DCHECK(g_id_to_socket->find(socket_id_) != g_id_to_socket->end());
-  g_id_to_socket->erase(socket_id_);
-
-  GetDispatcher()->SendToBrowser(
-      new PpapiHostMsg_PPBFlashTCPSocket_Disconnect(socket_id_));
-  socket_id_ = 0;
-
-  PostAbortAndClearIfNecessary(&connect_callback_);
-  PostAbortAndClearIfNecessary(&read_callback_);
-  PostAbortAndClearIfNecessary(&write_callback_);
-  read_buffer_ = NULL;
-  bytes_to_read_ = -1;
-}
-
-void FlashTCPSocket::OnConnectCompleted(
-    bool succeeded,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
-  if (connection_state_ != BEFORE_CONNECT || !connect_callback_.func) {
-    NOTREACHED();
-    return;
-  }
-
-  if (succeeded) {
-    local_addr_ = local_addr;
-    remote_addr_ = remote_addr;
-    connection_state_ = CONNECTED;
-  }
-  PP_RunAndClearCompletionCallback(&connect_callback_,
-                                   succeeded ? PP_OK : PP_ERROR_FAILED);
-}
-
-void FlashTCPSocket::OnReadCompleted(bool succeeded, const std::string& data) {
-  if (!read_callback_.func || !read_buffer_) {
-    NOTREACHED();
-    return;
-  }
-
-  if (succeeded) {
-    CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
-    if (!data.empty())
-      memcpy(read_buffer_, data.c_str(), data.size());
-  }
-  read_buffer_ = NULL;
-  bytes_to_read_ = -1;
-
-  PP_RunAndClearCompletionCallback(
-      &read_callback_,
-      succeeded ? data.size() : static_cast<int32_t>(PP_ERROR_FAILED));
-}
-
-void FlashTCPSocket::OnWriteCompleted(bool succeeded, int32_t bytes_written) {
-  if (!write_callback_.func || (succeeded && bytes_written < 0)) {
-    NOTREACHED();
-    return;
-  }
-
-  PP_RunAndClearCompletionCallback(
-      &write_callback_,
-      succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
-}
-
-int32_t FlashTCPSocket::ConnectWithMessage(IPC::Message* msg,
-                                           PP_CompletionCallback callback) {
-  scoped_ptr<IPC::Message> msg_deletor(msg);
-  if (!callback.func)
-    return PP_ERROR_BADARGUMENT;
-  if (connection_state_ != BEFORE_CONNECT)
-    return PP_ERROR_FAILED;
-  if (connect_callback_.func)
-    return PP_ERROR_INPROGRESS;  // Can only have one pending request.
-
-  connect_callback_ = callback;
-  // Send the request, the browser will call us back via ConnectACK.
-  GetDispatcher()->SendToBrowser(msg_deletor.release());
-  return PP_OK_COMPLETIONPENDING;
-}
-
-void FlashTCPSocket::PostAbortAndClearIfNecessary(
-    PP_CompletionCallback* callback) {
-  DCHECK(callback);
-
-  if (callback->func) {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     new AbortCallbackTask(*callback));
-    *callback = PP_BlockUntilComplete();
-  }
-}
-
-PPB_Flash_TCPSocket_Proxy::PPB_Flash_TCPSocket_Proxy(
-    Dispatcher* dispatcher,
-    const void* target_interface)
-    : InterfaceProxy(dispatcher, target_interface) {
-}
-
-PPB_Flash_TCPSocket_Proxy::~PPB_Flash_TCPSocket_Proxy() {
-}
-
-// static
-const InterfaceProxy::Info* PPB_Flash_TCPSocket_Proxy::GetInfo() {
-  static const Info info = {
-    ::ppapi::thunk::GetPPB_Flash_TCPSocket_Thunk(),
-    PPB_FLASH_TCPSOCKET_INTERFACE,
-    INTERFACE_ID_PPB_FLASH_TCPSOCKET,
-    false,
-    &CreateFlashTCPSocketProxy,
-  };
-  return &info;
-}
-
-// static
-PP_Resource PPB_Flash_TCPSocket_Proxy::CreateProxyResource(
-    PP_Instance instance) {
-  PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance);
-  if (!dispatcher)
-    return 0;
-
-  uint32 socket_id = 0;
-  dispatcher->SendToBrowser(new PpapiHostMsg_PPBFlashTCPSocket_Create(
-      INTERFACE_ID_PPB_FLASH_TCPSOCKET, dispatcher->plugin_dispatcher_id(),
-      &socket_id));
-  if (socket_id == 0)
-    return 0;
-
-  linked_ptr<FlashTCPSocket> object(new FlashTCPSocket(
-      HostResource::MakeInstanceOnly(instance), socket_id));
-  return PluginResourceTracker::GetInstance()->AddResource(object);
-}
-
-bool PPB_Flash_TCPSocket_Proxy::OnMessageReceived(const IPC::Message& msg) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PPB_Flash_TCPSocket_Proxy, msg)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ConnectACK, OnMsgConnectACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_ReadACK, OnMsgReadACK)
-    IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashTCPSocket_WriteACK, OnMsgWriteACK)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void PPB_Flash_TCPSocket_Proxy::OnMsgConnectACK(
-    uint32 /* plugin_dispatcher_id */,
-    uint32 socket_id,
-    bool succeeded,
-    const PP_Flash_NetAddress& local_addr,
-    const PP_Flash_NetAddress& remote_addr) {
-  if (!g_id_to_socket) {
-    NOTREACHED();
-    return;
-  }
-  IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
-  if (iter == g_id_to_socket->end())
-    return;
-  iter->second->OnConnectCompleted(succeeded, local_addr, remote_addr);
-}
-
-void PPB_Flash_TCPSocket_Proxy::OnMsgReadACK(uint32 /* plugin_dispatcher_id */,
-                                             uint32 socket_id,
-                                             bool succeeded,
-                                             const std::string& data) {
-  if (!g_id_to_socket) {
-    NOTREACHED();
-    return;
-  }
-  IDToSocketMap::iterator iter = g_id_to_socket->find(socket_id);
-  if (iter == g_id_to_socket->end())
-    return;
-  iter->second->OnReadCompleted(succeeded, data);
-}
-
-void PPB_Flash_TCPSocket_Proxy::OnMsgWriteACK(uint32 /* plugin_dispatcher_id */,
-                                              uint32 socket_id,
-                                              bool succeeded,
-                                              int32_t bytes_written) {
-  if (!g_id_to_socket) {
-    NOTREACHED();
-    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 pp
diff --git a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h b/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
deleted file mode 100644
index aac9bbd..0000000
--- a/ppapi/proxy/ppb_flash_tcp_socket_proxy.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// 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.
-
-#ifndef PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
-#define PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
-
-#include <string>
-
-#include "base/basictypes.h"
-#include "ppapi/c/pp_instance.h"
-#include "ppapi/c/pp_resource.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
-#include "ppapi/proxy/interface_proxy.h"
-
-namespace pp {
-namespace proxy {
-
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashTCPSocket_Read
-// message is allowed to request.
-extern const int32_t kFlashTCPSocketMaxReadSize;
-// The maximum number of bytes that each PpapiHostMsg_PPBFlashTCPSocket_Write
-// message is allowed to carry.
-extern const int32_t kFlashTCPSocketMaxWriteSize;
-
-class PPB_Flash_TCPSocket_Proxy : public InterfaceProxy {
- public:
-  PPB_Flash_TCPSocket_Proxy(Dispatcher* dispatcher,
-                            const void* target_interface);
-  virtual ~PPB_Flash_TCPSocket_Proxy();
-
-  static const Info* GetInfo();
-
-  static PP_Resource CreateProxyResource(PP_Instance instance);
-
-  // InterfaceProxy implementation.
-  virtual bool OnMessageReceived(const IPC::Message& msg);
-
- private:
-  // Browser->plugin message handlers.
-  void OnMsgConnectACK(uint32 plugin_dispatcher_id,
-                       uint32 socket_id,
-                       bool succeeded,
-                       const PP_Flash_NetAddress& local_addr,
-                       const PP_Flash_NetAddress& remote_addr);
-  void OnMsgReadACK(uint32 plugin_dispatcher_id,
-                    uint32 socket_id,
-                    bool succeeded,
-                    const std::string& data);
-  void OnMsgWriteACK(uint32 plugin_dispatcher_id,
-                     uint32 socket_id,
-                     bool succeeded,
-                     int32_t bytes_written);
-
-  DISALLOW_COPY_AND_ASSIGN(PPB_Flash_TCPSocket_Proxy);
-};
-
-}  // namespace proxy
-}  // namespace pp
-
-#endif  // PPAPI_PROXY_PPB_FLASH_TCP_SOCKET_PROXY_H_
diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc
index 07d6248..095efb0 100644
--- a/ppapi/proxy/resource_creation_proxy.cc
+++ b/ppapi/proxy/resource_creation_proxy.cc
@@ -22,7 +22,6 @@
 #include "ppapi/proxy/ppb_file_system_proxy.h"
 #include "ppapi/proxy/ppb_flash_menu_proxy.h"
 #include "ppapi/proxy/ppb_flash_net_connector_proxy.h"
-#include "ppapi/proxy/ppb_flash_tcp_socket_proxy.h"
 #include "ppapi/proxy/ppb_font_proxy.h"
 #include "ppapi/proxy/ppb_graphics_2d_proxy.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
@@ -139,11 +138,6 @@ PP_Resource ResourceCreationProxy::CreateFlashNetConnector(
   return PPB_Flash_NetConnector_Proxy::CreateProxyResource(instance);
 }
 
-PP_Resource ResourceCreationProxy::CreateFlashTCPSocket(
-    PP_Instance instance) {
-  return PPB_Flash_TCPSocket_Proxy::CreateProxyResource(instance);
-}
-
 PP_Resource ResourceCreationProxy::CreateFontObject(
     PP_Instance instance,
     const PP_FontDescription_Dev* description) {
diff --git a/ppapi/proxy/resource_creation_proxy.h b/ppapi/proxy/resource_creation_proxy.h
index 218607b..107ac3c 100644
--- a/ppapi/proxy/resource_creation_proxy.h
+++ b/ppapi/proxy/resource_creation_proxy.h
@@ -63,7 +63,6 @@ class ResourceCreationProxy : public ::ppapi::FunctionGroupBase,
   virtual PP_Resource CreateFlashMenu(PP_Instance instance,
                                       const PP_Flash_Menu* menu_data) OVERRIDE;
   virtual PP_Resource CreateFlashNetConnector(PP_Instance instance) OVERRIDE;
-  virtual PP_Resource CreateFlashTCPSocket(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateFontObject(
       PP_Instance instance,
       const PP_FontDescription_Dev* description) OVERRIDE;
diff --git a/ppapi/shared_impl/resource_object_base.h b/ppapi/shared_impl/resource_object_base.h
index 77f6dd16..d61e55b 100644
--- a/ppapi/shared_impl/resource_object_base.h
+++ b/ppapi/shared_impl/resource_object_base.h
@@ -23,7 +23,6 @@
   F(PPB_Find_API) \
   F(PPB_Flash_Menu_API) \
   F(PPB_Flash_NetConnector_API) \
-  F(PPB_Flash_TCPSocket_API) \
   F(PPB_Font_API) \
   F(PPB_Graphics2D_API) \
   F(PPB_Graphics3D_API) \
diff --git a/ppapi/tests/all_c_includes.h b/ppapi/tests/all_c_includes.h
index d4f510d..7dd0960 100644
--- a/ppapi/tests/all_c_includes.h
+++ b/ppapi/tests/all_c_includes.h
@@ -82,7 +82,6 @@
 #include "ppapi/c/ppp_messaging.h"
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_menu.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppb_nacl_private.h"
 #include "ppapi/c/private/ppb_pdf.h"
diff --git a/ppapi/thunk/ppb_flash_tcp_socket_api.h b/ppapi/thunk/ppb_flash_tcp_socket_api.h
deleted file mode 100644
index d18eb6e..0000000
--- a/ppapi/thunk/ppb_flash_tcp_socket_api.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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.
-
-#ifndef PPAPI_THUNK_PPB_FLASH_TCP_SOCKET_API_H_
-#define PPAPI_THUNK_PPB_FLASH_TCP_SOCKET_API_H_
-
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
-
-namespace ppapi {
-namespace thunk {
-
-class PPB_Flash_TCPSocket_API {
- public:
-  virtual ~PPB_Flash_TCPSocket_API() {}
-
-  virtual int32_t Connect(const char* host,
-                          uint16_t port,
-                          PP_CompletionCallback callback) = 0;
-  virtual int32_t ConnectWithNetAddress(const PP_Flash_NetAddress* addr,
-                                        PP_CompletionCallback callback) = 0;
-  virtual PP_Bool GetLocalAddress(PP_Flash_NetAddress* local_addr) = 0;
-  virtual PP_Bool GetRemoteAddress(PP_Flash_NetAddress* remote_addr) = 0;
-  virtual int32_t InitiateSSL(const char* server_name,
-                              PP_CompletionCallback callback) = 0;
-  virtual int32_t Read(char* buffer,
-                       int32_t bytes_to_read,
-                       PP_CompletionCallback callback) = 0;
-  virtual int32_t Write(const char* buffer,
-                        int32_t bytes_to_write,
-                        PP_CompletionCallback callback) = 0;
-  virtual void Disconnect() = 0;
-};
-
-}  // namespace thunk
-}  // namespace ppapi
-
-#endif  // PPAPI_THUNK_PPB_FLASH_TCP_SOCKET_API_H_
diff --git a/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc b/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc
deleted file mode 100644
index 815dd53..0000000
--- a/ppapi/thunk/ppb_flash_tcp_socket_thunk.cc
+++ /dev/null
@@ -1,121 +0,0 @@
-// 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 "ppapi/c/pp_completion_callback.h"
-#include "ppapi/c/pp_errors.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
-#include "ppapi/thunk/thunk.h"
-#include "ppapi/thunk/enter.h"
-#include "ppapi/thunk/ppb_flash_tcp_socket_api.h"
-#include "ppapi/thunk/resource_creation_api.h"
-
-namespace ppapi {
-namespace thunk {
-
-namespace {
-
-PP_Resource Create(PP_Instance instance) {
-  EnterFunction<ResourceCreationAPI> enter(instance, true);
-  if (enter.failed())
-    return 0;
-  return enter.functions()->CreateFlashTCPSocket(instance);
-}
-
-PP_Bool IsFlashTCPSocket(PP_Resource resource) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(resource, false);
-  return PP_FromBool(enter.succeeded());
-}
-
-int32_t Connect(PP_Resource tcp_socket,
-                const char* host,
-                uint16_t port,
-                PP_CompletionCallback callback) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  return enter.object()->Connect(host, port, callback);
-}
-
-int32_t ConnectWithNetAddress(PP_Resource tcp_socket,
-                              const PP_Flash_NetAddress* addr,
-                              PP_CompletionCallback callback) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  return enter.object()->ConnectWithNetAddress(addr, callback);
-}
-
-PP_Bool GetLocalAddress(PP_Resource tcp_socket,
-                        PP_Flash_NetAddress* local_addr) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_FALSE;
-  return enter.object()->GetLocalAddress(local_addr);
-}
-
-PP_Bool GetRemoteAddress(PP_Resource tcp_socket,
-                         PP_Flash_NetAddress* remote_addr) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_FALSE;
-  return enter.object()->GetRemoteAddress(remote_addr);
-}
-
-int32_t InitiateSSL(PP_Resource tcp_socket,
-                    const char* server_name,
-                    PP_CompletionCallback callback) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  return enter.object()->InitiateSSL(server_name, callback);
-}
-
-int32_t Read(PP_Resource tcp_socket,
-             char* buffer,
-             int32_t bytes_to_read,
-             PP_CompletionCallback callback) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  return enter.object()->Read(buffer, bytes_to_read, callback);
-}
-
-int32_t Write(PP_Resource tcp_socket,
-              const char* buffer,
-              int32_t bytes_to_write,
-              PP_CompletionCallback callback) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.failed())
-    return PP_ERROR_BADRESOURCE;
-  return enter.object()->Write(buffer, bytes_to_write, callback);
-}
-
-void Disconnect(PP_Resource tcp_socket) {
-  EnterResource<PPB_Flash_TCPSocket_API> enter(tcp_socket, true);
-  if (enter.succeeded())
-    enter.object()->Disconnect();
-}
-
-const PPB_Flash_TCPSocket g_ppb_flash_tcp_socket_thunk = {
-  &Create,
-  &IsFlashTCPSocket,
-  &Connect,
-  &ConnectWithNetAddress,
-  &GetLocalAddress,
-  &GetRemoteAddress,
-  &InitiateSSL,
-  &Read,
-  &Write,
-  &Disconnect
-};
-
-}  // namespace
-
-const PPB_Flash_TCPSocket* GetPPB_Flash_TCPSocket_Thunk() {
-  return &g_ppb_flash_tcp_socket_thunk;
-}
-
-}  // namespace thunk
-}  // namespace ppapi
-
diff --git a/ppapi/thunk/resource_creation_api.h b/ppapi/thunk/resource_creation_api.h
index e2e5ba1..c998b56 100644
--- a/ppapi/thunk/resource_creation_api.h
+++ b/ppapi/thunk/resource_creation_api.h
@@ -63,7 +63,6 @@ class ResourceCreationAPI {
   virtual PP_Resource CreateFlashMenu(PP_Instance instance,
                                       const PP_Flash_Menu* menu_data) = 0;
   virtual PP_Resource CreateFlashNetConnector(PP_Instance instance) = 0;
-  virtual PP_Resource CreateFlashTCPSocket(PP_Instance instace) = 0;
   // Note: can't be called CreateFont due to Windows #defines.
   virtual PP_Resource CreateFontObject(
       PP_Instance instance,
diff --git a/ppapi/thunk/thunk.h b/ppapi/thunk/thunk.h
index 9fb84b3..645c5c6 100644
--- a/ppapi/thunk/thunk.h
+++ b/ppapi/thunk/thunk.h
@@ -24,7 +24,6 @@ struct PPB_FileSystem_Dev;
 struct PPB_Find_Dev;
 struct PPB_Flash_Menu;
 struct PPB_Flash_NetConnector;
-struct PPB_Flash_TCPSocket;
 struct PPB_Font_Dev;
 struct PPB_Fullscreen_Dev;
 struct PPB_GLESChromiumTextureMapping_Dev;
@@ -76,7 +75,6 @@ const PPB_FileSystem_Dev* GetPPB_FileSystem_Thunk();
 const PPB_Find_Dev* GetPPB_Find_Thunk();
 const PPB_Flash_Menu* GetPPB_Flash_Menu_Thunk();
 const PPB_Flash_NetConnector* GetPPB_Flash_NetConnector_Thunk();
-const PPB_Flash_TCPSocket* GetPPB_Flash_TCPSocket_Thunk();
 const PPB_Font_Dev* GetPPB_Font_Thunk();
 const PPB_Fullscreen_Dev* GetPPB_Fullscreen_Thunk();
 const PPB_GLESChromiumTextureMapping_Dev*
diff --git a/webkit/plugins/ppapi/plugin_module.cc b/webkit/plugins/ppapi/plugin_module.cc
index bd7bf11..340d0e44 100644
--- a/webkit/plugins/ppapi/plugin_module.cc
+++ b/webkit/plugins/ppapi/plugin_module.cc
@@ -61,7 +61,6 @@
 #include "ppapi/c/private/ppb_flash.h"
 #include "ppapi/c/private/ppb_flash_clipboard.h"
 #include "ppapi/c/private/ppb_flash_file.h"
-#include "ppapi/c/private/ppb_flash_tcp_socket.h"
 #include "ppapi/c/private/ppb_instance_private.h"
 #include "ppapi/c/private/ppb_pdf.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
@@ -274,8 +273,6 @@ const void* GetInterface(const char* name) {
     return PPB_Flash_File_ModuleLocal_Impl::GetInterface();
   if (strcmp(name, PPB_FLASH_MENU_INTERFACE) == 0)
     return ::ppapi::thunk::GetPPB_Flash_Menu_Thunk();
-  if (strcmp(name, PPB_FLASH_TCPSOCKET_INTERFACE) == 0)
-    return ::ppapi::thunk::GetPPB_Flash_TCPSocket_Thunk();
   if (strcmp(name, PPB_FONT_DEV_INTERFACE) == 0)
     return ::ppapi::thunk::GetPPB_Font_Thunk();
   if (strcmp(name, PPB_FULLSCREEN_DEV_INTERFACE) == 0)
diff --git a/webkit/plugins/ppapi/resource_creation_impl.cc b/webkit/plugins/ppapi/resource_creation_impl.cc
index ef2830f..9dc2800 100644
--- a/webkit/plugins/ppapi/resource_creation_impl.cc
+++ b/webkit/plugins/ppapi/resource_creation_impl.cc
@@ -154,12 +154,6 @@ PP_Resource ResourceCreationImpl::CreateFlashNetConnector(
   return ReturnResource(new PPB_Flash_NetConnector_Impl(instance_));
 }
 
-PP_Resource ResourceCreationImpl::CreateFlashTCPSocket(
-    PP_Instance instance) {
-  // Creating TCP socket resource at the renderer side is not supported.
-  return 0;
-}
-
 PP_Resource ResourceCreationImpl::CreateFontObject(
     PP_Instance pp_instance,
     const PP_FontDescription_Dev* description) {
diff --git a/webkit/plugins/ppapi/resource_creation_impl.h b/webkit/plugins/ppapi/resource_creation_impl.h
index b20df64..e970d57 100644
--- a/webkit/plugins/ppapi/resource_creation_impl.h
+++ b/webkit/plugins/ppapi/resource_creation_impl.h
@@ -56,7 +56,6 @@ class ResourceCreationImpl : public ::ppapi::FunctionGroupBase,
   virtual PP_Resource CreateFlashMenu(PP_Instance instance,
                                       const PP_Flash_Menu* menu_data) OVERRIDE;
   virtual PP_Resource CreateFlashNetConnector(PP_Instance instance) OVERRIDE;
-  virtual PP_Resource CreateFlashTCPSocket(PP_Instance instance) OVERRIDE;
   virtual PP_Resource CreateFontObject(
       PP_Instance instance,
       const PP_FontDescription_Dev* description) OVERRIDE;