Refactor the P2PSocketDispatcher to be created on the RenderThread instead of the RenderView.

content/browser/renderer_host/p2p/socket_host_tcp.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/browser/renderer_host/p2p/socket_host_tcp.h"
 
 #include "base/sys_byteorder.h"
 #include "content/common/p2p_messages.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace {
 const int kReadBufferSize = 4096;
 const int kPacketHeaderSize = sizeof(uint16);
 }  // namespace
 
 namespace content {
 
-P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender,
-                                   int routing_id, int id)
-    : P2PSocketHost(message_sender, routing_id, id),
+P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender, int id)
+    : P2PSocketHost(message_sender, id),
       connected_(false) {
 }
 
 P2PSocketHostTcp::~P2PSocketHostTcp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
@@ skipping 31 matching lines @@
   }
 
   return state_ != STATE_ERROR;
 }
 
 void P2PSocketHostTcp::OnError() {
   socket_.reset();
 
   if (state_ == STATE_UNINITIALIZED || state_ == STATE_CONNECTING ||
       state_ == STATE_OPEN) {
-    message_sender_->Send(new P2PMsg_OnError(routing_id_, id_));
+    message_sender_->Send(new P2PMsg_OnError(id_));
   }
 
   state_ = STATE_ERROR;
 }
 
 void P2PSocketHostTcp::OnConnected(int result) {
   DCHECK_EQ(state_, STATE_CONNECTING);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   if (result != net::OK) {
     OnError();
     return;
   }
 
   if (!socket_->SetSendBufferSize(kMaxSendBufferSize)) {
     LOG(WARNING) << "Failed to set send buffer size for TCP socket.";
   }
 
   net::IPEndPoint address;
   result = socket_->GetLocalAddress(&address);
   if (result < 0) {
     LOG(ERROR) << "P2PSocket::Init(): unable to get local address: "
                << result;
     OnError();
     return;
   }
 
   VLOG(1) << "Local address: " << address.ToString();
   state_ = STATE_OPEN;
-  message_sender_->Send(new P2PMsg_OnSocketCreated(routing_id_, id_, address));
+  message_sender_->Send(new P2PMsg_OnSocketCreated(id_, address));
   DoRead();
 }
 
 void P2PSocketHostTcp::DoRead() {
   int result;
   do {
     if (!read_buffer_) {
       read_buffer_ = new net::GrowableIOBuffer();
       read_buffer_->SetCapacity(kReadBufferSize);
     } else if (read_buffer_->RemainingCapacity() < kReadBufferSize) {
@@ skipping 27 matching lines @@
     } else if (!stun || type == STUN_DATA_INDICATION) {
       LOG(ERROR) << "Received unexpected data packet from "
                  << remote_address_.ToString()
                  << " before STUN binding is finished. "
                  << "Terminating connection.";
       OnError();
       return;
     }
   }
 
-  message_sender_->Send(new P2PMsg_OnDataReceived(routing_id_, id_,
-                                                  remote_address_, data));
+  message_sender_->Send(new P2PMsg_OnDataReceived(id_, remote_address_, data));
 }
 
 void P2PSocketHostTcp::DidCompleteRead(int result) {
   DCHECK_EQ(state_, STATE_OPEN);
 
   if (result == net::ERR_IO_PENDING) {
     return;
   } else if (result < 0){
     LOG(ERROR) << "Error when reading from TCP socket: " << result;
     OnError();
@@ skipping 103 matching lines @@
 }
 
 P2PSocketHost* P2PSocketHostTcp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 } // namespace content