Implements RTP header dumping.

content/browser/renderer_host/p2p/socket_host_udp.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_udp.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host_throttler.h"
@@ skipping 48 matching lines @@
       size(content.size()),
       packet_options(options),
       id(id) {
   memcpy(data->data(), &content[0], size);
 }
 
 P2PSocketHostUdp::PendingPacket::~PendingPacket() {
 }
 
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender,
-                                   int id,
+                                   int socket_id,
+                                   int render_process_host_id,
                                    P2PMessageThrottler* throttler)
-    : P2PSocketHost(message_sender, id),
-      socket_(new net::UDPServerSocket(
-          GetContentClient()->browser()->GetNetLog(),
-          net::NetLog::Source())),
+    : P2PSocketHost(message_sender, socket_id, render_process_host_id),
+      socket_(
+          new net::UDPServerSocket(GetContentClient()->browser()->GetNetLog(),
+                                   net::NetLog::Source())),
       send_pending_(false),
       last_dscp_(net::DSCP_CS0),
       throttler_(throttler) {
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
@@ skipping 81 matching lines @@
       } else if (!stun || type == STUN_DATA_INDICATION) {
         LOG(ERROR) << "Received unexpected data packet from "
                    << recv_address_.ToString()
                    << " before STUN binding is finished.";
         return;
       }
     }
 
     message_sender_->Send(new P2PMsg_OnDataReceived(
         id_, recv_address_, data, base::TimeTicks::Now()));
+
+    if (dump_incoming_rtp_packet_)
+      DumpRtpPacket(data.data(), data.size(), true);
   } else if (result < 0 && !IsTransientError(result)) {
     LOG(ERROR) << "Error when reading from UDP socket: " << result;
     OnError();
   }
 }
 
 void P2PSocketHostUdp::Send(const net::IPEndPoint& to,
                             const std::vector<char>& data,
                             const talk_base::PacketOptions& options,
                             uint64 packet_id) {
@@ skipping 68 matching lines @@
         packet.to,
         base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this),
                    packet.id));
   }
 
   if (result == net::ERR_IO_PENDING) {
     send_pending_ = true;
   } else {
     HandleSendResult(packet.id, result);
   }
+
+  if (dump_outgoing_rtp_packet_)
+    DumpRtpPacket(packet.data->data(), packet.size, false);
 }
 
 void P2PSocketHostUdp::OnSend(uint64 packet_id, int result) {
   DCHECK(send_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
   HandleSendResult(packet_id, result);
 
@@ skipping 36 matching lines @@
     case P2P_SOCKET_OPT_DSCP:
       return (net::OK == socket_->SetDiffServCodePoint(
           static_cast<net::DiffServCodePoint>(value))) ? true : false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace content