Implements RTP header dumping.

content/browser/renderer_host/p2p/socket_host_tcp_server.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_server.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/common/p2p_messages.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/socket/stream_socket.h"
 
 namespace {
 const int kListenBacklog = 5;
 }  // namespace
 
 namespace content {
 
-P2PSocketHostTcpServer::P2PSocketHostTcpServer(
-    IPC::Sender* message_sender, int id, P2PSocketType client_type)
-    : P2PSocketHost(message_sender, id),
+P2PSocketHostTcpServer::P2PSocketHostTcpServer(IPC::Sender* message_sender,
+                                               int socket_id,
+                                               int render_process_host_id,
+                                               P2PSocketType client_type)
+    : P2PSocketHost(message_sender, socket_id, render_process_host_id),
       client_type_(client_type),
       socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
-      accept_callback_(
-          base::Bind(&P2PSocketHostTcpServer::OnAccepted,
-                     base::Unretained(this))) {
+      accept_callback_(base::Bind(&P2PSocketHostTcpServer::OnAccepted,
+                                  base::Unretained(this))) {
 }
 
 P2PSocketHostTcpServer::~P2PSocketHostTcpServer() {
   STLDeleteContainerPairSecondPointers(accepted_sockets_.begin(),
                                        accepted_sockets_.end());
 
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
@@ skipping 85 matching lines @@
     const net::IPEndPoint& remote_address, int id) {
   AcceptedSocketsMap::iterator it = accepted_sockets_.find(remote_address);
   if (it == accepted_sockets_.end())
     return NULL;
 
   net::StreamSocket* socket = it->second;
   accepted_sockets_.erase(it);
 
   scoped_ptr<P2PSocketHostTcpBase> result;
   if (client_type_ == P2P_SOCKET_TCP_CLIENT) {
-    result.reset(new P2PSocketHostTcp(message_sender_, id, client_type_, NULL));
+    result.reset(new P2PSocketHostTcp(
+        message_sender_, id, render_process_host_id_, client_type_, NULL));
   } else {
     result.reset(new P2PSocketHostStunTcp(
-                    message_sender_, id, client_type_, NULL));
+        message_sender_, id, render_process_host_id_, client_type_, NULL));
   }
   if (!result->InitAccepted(remote_address, socket))
     return NULL;
   return result.release();
 }
 
 bool P2PSocketHostTcpServer::SetOption(P2PSocketOption option,
                                        int value) {
   // Currently we don't have use case tcp server sockets are used for p2p.
   return false;
 }
 
 }  // namespace content