A few more cleanups to the pepper code. Dispatch IPCs in the sockets implementations directly by ha…

content/renderer/pepper/ppb_tcp_server_socket_private_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/pepper/ppb_tcp_server_socket_private_impl.h"
 
 #include "base/logging.h"
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/pepper_helper_impl.h"
+#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/ppb_tcp_socket_private_impl.h"
-#include "content/renderer/pepper/resource_helper.h"
+#include "content/renderer/render_thread_impl.h"
 #include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/thunk/enter.h"
 
 namespace content {
 
 PPB_TCPServerSocket_Private_Impl::PPB_TCPServerSocket_Private_Impl(
     PP_Instance instance)
-    : ::ppapi::PPB_TCPServerSocket_Shared(instance) {
+    : ::ppapi::PPB_TCPServerSocket_Shared(instance),
+      routing_id_(RenderThreadImpl::current()->GenerateRoutingID()) {
+  ChildThread::current()->AddRoute(routing_id_, this);
 }
 
 PPB_TCPServerSocket_Private_Impl::~PPB_TCPServerSocket_Private_Impl() {
   StopListening();
+  ChildThread::current()->RemoveRoute(routing_id_);
 }
 
 PP_Resource PPB_TCPServerSocket_Private_Impl::CreateResource(
     PP_Instance instance) {
   PPB_TCPServerSocket_Private_Impl* socket =
       new PPB_TCPServerSocket_Private_Impl(instance);
   return socket->GetReference();
 }
 
-void PPB_TCPServerSocket_Private_Impl::OnAcceptCompleted(
-    bool succeeded,
+void PPB_TCPServerSocket_Private_Impl::SendListen(
+    const PP_NetAddress_Private& addr,
+    int32_t backlog) {
+  RenderThreadImpl::current()->Send(new PpapiHostMsg_PPBTCPServerSocket_Listen(
+      routing_id_, 0, pp_resource(), addr, backlog));
+}
+
+void PPB_TCPServerSocket_Private_Impl::SendAccept() {
+  int new_socket_routing_id = RenderThreadImpl::current()->GenerateRoutingID();
+  RenderThreadImpl::current()->Send(new PpapiHostMsg_PPBTCPServerSocket_Accept(
+      new_socket_routing_id, socket_id_));
+}
+
+void PPB_TCPServerSocket_Private_Impl::SendStopListening() {
+  if (socket_id_ != 0) {
+    RenderThreadImpl::current()->Send(
+        new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id_));
+  }
+}
+
+bool PPB_TCPServerSocket_Private_Impl::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PPB_TCPServerSocket_Private_Impl, message)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_ListenACK,
+                        OnTCPServerSocketListenACK)
+    IPC_MESSAGE_HANDLER(PpapiMsg_PPBTCPServerSocket_AcceptACK,
+                        OnTCPServerSocketAcceptACK)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PPB_TCPServerSocket_Private_Impl::OnTCPServerSocketListenACK(
+    uint32 plugin_dispatcher_id,
+    PP_Resource socket_resource,
+    uint32 socket_id,
+    const PP_NetAddress_Private& local_addr,
+    int32_t status) {
+  ppapi::thunk::EnterResource<ppapi::thunk::PPB_TCPServerSocket_Private_API>
+      enter(socket_resource, true);
+  if (enter.succeeded()) {
+    OnListenCompleted(socket_id, local_addr, status);
+  } else if (socket_id != 0 && status == PP_OK) {
+    // StopListening was called before completion of Listen.
+    RenderThreadImpl::current()->Send(
+        new PpapiHostMsg_PPBTCPServerSocket_Destroy(socket_id));
+  }
+}
+
+void PPB_TCPServerSocket_Private_Impl::OnTCPServerSocketAcceptACK(
+    int32 socket_routing_id,
+    uint32 socket_id,
     uint32 accepted_socket_id,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
+  bool succeeded = (accepted_socket_id != 0);
   if (!::ppapi::TrackedCallback::IsPending(accept_callback_) ||
       !tcp_socket_buffer_) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
     *tcp_socket_buffer_ =
         PPB_TCPSocket_Private_Impl::CreateConnectedSocket(pp_instance(),
+                                                          socket_routing_id,
                                                           accepted_socket_id,
                                                           local_addr,
                                                           remote_addr);
   }
   tcp_socket_buffer_ = NULL;
 
   accept_callback_->Run(succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
-void PPB_TCPServerSocket_Private_Impl::SendListen(
-    const PP_NetAddress_Private& addr,
-    int32_t backlog) {
-  PepperHelperImpl* helper = GetHelper();
-  if (!helper)
-    return;
-
-  helper->Send(new PpapiHostMsg_PPBTCPServerSocket_Listen(
-      helper->routing_id(), 0, pp_resource(), addr, backlog));
-}
-
-void PPB_TCPServerSocket_Private_Impl::SendAccept() {
-  PepperHelperImpl* helper = GetHelper();
-  if (!helper)
-    return;
-
-  helper->Send(new PpapiHostMsg_PPBTCPServerSocket_Accept(
-      helper->routing_id(), socket_id_));
-}
-
-void PPB_TCPServerSocket_Private_Impl::SendStopListening() {
-  PepperHelperImpl* helper = GetHelper();
-  if (!helper)
-    return;
-
-  if (socket_id_ != 0) {
-    helper->Send(new PpapiHostMsg_PPBTCPServerSocket_Destroy(
-        socket_id_));
-    helper->TCPServerSocketStopListening(socket_id_);
-  }
-}
-
-PepperHelperImpl* PPB_TCPServerSocket_Private_Impl::GetHelper() {
-  return ResourceHelper::GetHelper(this);
-}
-
 }  // namespace content