Implements RTP header dumping.

content/browser/renderer_host/p2p/socket_dispatcher_host.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_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/common/p2p_messages.h"
@@ skipping 77 matching lines @@
   net::AddressList addresses_;
 
   std::string host_name_;
   net::SingleRequestHostResolver resolver_;
 
   DoneCallback done_callback_;
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
     content::ResourceContext* resource_context,
-    net::URLRequestContextGetter* url_context)
+    net::URLRequestContextGetter* url_context,
+    int render_process_host_id)
     : BrowserMessageFilter(P2PMsgStart),
       resource_context_(resource_context),
       url_context_(url_context),
-      monitoring_networks_(false) {
+      render_process_host_id_(render_process_host_id),
+      monitoring_networks_(false),
+      dump_incoming_rtp_packet_(false),
+      dump_outgoing_rtp_packet_(false) {
 }
 
 void P2PSocketDispatcherHost::OnChannelClosing() {
   // Since the IPC channel is gone, close pending connections.
   STLDeleteContainerPairSecondPointers(sockets_.begin(), sockets_.end());
   sockets_.clear();
 
   STLDeleteContainerPointers(dns_requests_.begin(), dns_requests_.end());
   dns_requests_.clear();
 
@@ skipping 27 matching lines @@
   return handled;
 }
 
 void P2PSocketDispatcherHost::OnIPAddressChanged() {
   // Notify the renderer about changes to list of network interfaces.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE, base::Bind(
           &P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
+void P2PSocketDispatcherHost::StartRtpDump(bool incoming, bool outgoing) {
+  if (dump_incoming_rtp_packet_ != incoming ||

[Mallinath (Gone from Chromium), 2014/05/14 00:57:01]

Do we really need if condition here? Let socket decide how to handle these
values. wdyt?

[jiayl, 2014/05/14 15:54:51]

The check is to avoid unnecessary work if no change is made to the dump status.
We don't need to iterate the container if nothing needs to be changed.

+      dump_outgoing_rtp_packet_ != outgoing) {
+    dump_incoming_rtp_packet_ = incoming;
+    dump_outgoing_rtp_packet_ = outgoing;
+
+    for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
+      it->second->StartRtpDump(incoming, outgoing);
+  }
+}
+
+void P2PSocketDispatcherHost::StopRtpDump(bool incoming, bool outgoing) {
+  if (dump_incoming_rtp_packet_ == incoming ||

[Mallinath (Gone from Chromium), 2014/05/14 00:57:01]

same as above.

+      dump_outgoing_rtp_packet_ == outgoing) {
+    dump_incoming_rtp_packet_ = !incoming;
+    dump_outgoing_rtp_packet_ = !outgoing;
+
+    for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
+      it->second->StopRtpDump(incoming, outgoing);
+  }
+}
+
 P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
   DCHECK(sockets_.empty());
   DCHECK(dns_requests_.empty());
 
   if (monitoring_networks_)
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
 P2PSocketHost* P2PSocketDispatcherHost::LookupSocket(int socket_id) {
   SocketsMap::iterator it = sockets_.find(socket_id);
@@ skipping 33 matching lines @@
 void P2PSocketDispatcherHost::OnCreateSocket(
     P2PSocketType type, int socket_id,
     const net::IPEndPoint& local_address,
     const P2PHostAndIPEndPoint& remote_address) {
   if (LookupSocket(socket_id)) {
     LOG(ERROR) << "Received P2PHostMsg_CreateSocket for socket "
         "that already exists.";
     return;
   }
 
-  scoped_ptr<P2PSocketHost> socket(P2PSocketHost::Create(
-      this, socket_id, type, url_context_.get(), &throttler_));
+  scoped_ptr<P2PSocketHost> socket(
+      P2PSocketHost::Create(this,
+                            socket_id,
+                            render_process_host_id_,
+                            type,
+                            url_context_.get(),
+                            &throttler_));
 
   if (!socket) {
     Send(new P2PMsg_OnError(socket_id));
     return;
   }
 
   if (socket->Init(local_address, remote_address)) {
     sockets_[socket_id] = socket.release();
+
+    if (dump_incoming_rtp_packet_ || dump_outgoing_rtp_packet_) {
+      sockets_[socket_id]->StartRtpDump(dump_incoming_rtp_packet_,
+                                        dump_outgoing_rtp_packet_);
+    }
   }
 }
 
 void P2PSocketDispatcherHost::OnAcceptIncomingTcpConnection(
     int listen_socket_id, const net::IPEndPoint& remote_address,
     int connected_socket_id) {
   P2PSocketHost* socket = LookupSocket(listen_socket_id);
   if (!socket) {
     LOG(ERROR) << "Received P2PHostMsg_AcceptIncomingTcpConnection "
         "for invalid socket_id.";
@@ skipping 68 matching lines @@
 void P2PSocketDispatcherHost::OnAddressResolved(
     DnsRequest* request,
     const net::IPAddressList& addresses) {
   Send(new P2PMsg_GetHostAddressResult(request->request_id(), addresses));
 
   dns_requests_.erase(request);
   delete request;
 }
 
 }  // namespace content