Implements RTP header dumping.

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 "ipc/ipc_sender.h"
 #include "jingle/glue/fake_ssl_client_socket.h"
@@ skipping 27 matching lines @@
 bool IsPseudoTlsClientSocket(content::P2PSocketType type) {
   return (type == content::P2P_SOCKET_SSLTCP_CLIENT ||
           type == content::P2P_SOCKET_STUN_SSLTCP_CLIENT);
 }
 
 }  // namespace
 
 namespace content {
 
 P2PSocketHostTcpBase::P2PSocketHostTcpBase(
-    IPC::Sender* message_sender, int id,
-    P2PSocketType type, net::URLRequestContextGetter* url_context)
-    : P2PSocketHost(message_sender, id),
+    IPC::Sender* message_sender,
+    int socket_id,
+    int render_process_host_id,
+    P2PSocketType type,
+    net::URLRequestContextGetter* url_context)
+    : P2PSocketHost(message_sender, socket_id, render_process_host_id),
       write_pending_(false),
       connected_(false),
       type_(type),
       url_context_(url_context) {
 }
 
 P2PSocketHostTcpBase::~P2PSocketHostTcpBase() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
@@ skipping 219 matching lines @@
                  << remote_address_.ip_address.ToString()
                  << " before STUN binding is finished. "
                  << "Terminating connection.";
       OnError();
       return;
     }
   }
 
   message_sender_->Send(new P2PMsg_OnDataReceived(
       id_, remote_address_.ip_address, data, base::TimeTicks::Now()));
+
+  if (dump_incoming_rtp_packet_)
+    DumpRtpPacket(data.data(), data.size(), true);
 }
 
 // Note: dscp is not actually used on TCP sockets as this point,
 // but may be honored in the future.
 void P2PSocketHostTcpBase::Send(const net::IPEndPoint& to,
                                 const std::vector<char>& data,
                                 const talk_base::PacketOptions& options,
                                 uint64 packet_id) {
   if (!socket_) {
     // The Send message may be sent after the an OnError message was
@@ skipping 116 matching lines @@
     case P2P_SOCKET_OPT_SNDBUF:
       return socket_->SetSendBufferSize(value) == net::OK;
     case P2P_SOCKET_OPT_DSCP:
       return false;  // For TCP sockets DSCP setting is not available.
     default:
       NOTREACHED();
       return false;
   }
 }
 
-P2PSocketHostTcp::P2PSocketHostTcp(
-    IPC::Sender* message_sender, int id,
-    P2PSocketType type, net::URLRequestContextGetter* url_context)
-    : P2PSocketHostTcpBase(message_sender, id, type, url_context) {
+P2PSocketHostTcp::P2PSocketHostTcp(IPC::Sender* message_sender,
+                                   int socket_id,
+                                   int render_process_host_id,
+                                   P2PSocketType type,
+                                   net::URLRequestContextGetter* url_context)
+    : P2PSocketHostTcpBase(message_sender,
+                           socket_id,
+                           render_process_host_id,
+                           type,
+                           url_context) {
   DCHECK(type == P2P_SOCKET_TCP_CLIENT ||
          type == P2P_SOCKET_SSLTCP_CLIENT ||
          type == P2P_SOCKET_TLS_CLIENT);
 }
 
 P2PSocketHostTcp::~P2PSocketHostTcp() {
 }
 
 int P2PSocketHostTcp::ProcessInput(char* input, int input_len) {
   if (input_len < kPacketHeaderSize)
@@ skipping 22 matching lines @@
   packet_processing_helpers::ApplyPacketOptions(
       buffer->data() + kPacketHeaderSize,
       buffer->BytesRemaining() - kPacketHeaderSize,
       options, 0);
 
   WriteOrQueue(buffer);
 }
 
 // P2PSocketHostStunTcp
 P2PSocketHostStunTcp::P2PSocketHostStunTcp(
-    IPC::Sender* message_sender, int id,
-    P2PSocketType type, net::URLRequestContextGetter* url_context)
-    : P2PSocketHostTcpBase(message_sender, id, type, url_context) {
+    IPC::Sender* message_sender,
+    int socket_id,
+    int render_process_host_id,
+    P2PSocketType type,
+    net::URLRequestContextGetter* url_context)
+    : P2PSocketHostTcpBase(message_sender,
+                           socket_id,
+                           render_process_host_id,
+                           type,
+                           url_context) {
   DCHECK(type == P2P_SOCKET_STUN_TCP_CLIENT ||
          type == P2P_SOCKET_STUN_SSLTCP_CLIENT ||
          type == P2P_SOCKET_STUN_TLS_CLIENT);
 }
 
 P2PSocketHostStunTcp::~P2PSocketHostStunTcp() {
 }
 
 int P2PSocketHostStunTcp::ProcessInput(char* input, int input_len) {
   if (input_len < kPacketHeaderSize + kPacketLengthOffset)
@@ skipping 47 matching lines @@
 
   packet_processing_helpers::ApplyPacketOptions(
       buffer->data(), data.size(), options, 0);
 
   if (pad_bytes) {
     char padding[4] = {0};
     DCHECK_LE(pad_bytes, 4);
     memcpy(buffer->data() + data.size(), padding, pad_bytes);
   }
   WriteOrQueue(buffer);
+
+  if (dump_outgoing_rtp_packet_)
+    DumpRtpPacket(buffer->data(), data.size(), false);
 }
 
 int P2PSocketHostStunTcp::GetExpectedPacketSize(
     const char* data, int len, int* pad_bytes) {
   DCHECK_LE(kTurnChannelDataHeaderSize, len);
   // Both stun and turn had length at offset 2.
   int packet_size = base::NetToHost16(*reinterpret_cast<const uint16*>(
       data + kPacketLengthOffset));
 
   // Get packet type (STUN or TURN).
   uint16 msg_type = base::NetToHost16(*reinterpret_cast<const uint16*>(data));
 
   *pad_bytes = 0;
   // Add heder length to packet length.
   if ((msg_type & 0xC000) == 0) {
     packet_size += kStunHeaderSize;
   } else {
     packet_size += kTurnChannelDataHeaderSize;
     // Calculate any padding if present.
     if (packet_size % 4)
       *pad_bytes = 4 - packet_size % 4;
   }
   return packet_size;
 }
 
 }  // namespace content