Implements RTP header dumping.

content/browser/renderer_host/render_process_host_impl.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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 790 matching lines @@
             storage_partition_impl_->GetAppCacheService(),
             storage_partition_impl_->GetQuotaManager(),
             storage_partition_impl_->GetFileSystemContext(),
             storage_partition_impl_->GetDatabaseTracker(),
             storage_partition_impl_->GetIndexedDBContext(),
             storage_partition_impl_->GetServiceWorkerContext()),
         message_port_message_filter_));
   }
 
 #if defined(ENABLE_WEBRTC)
-  AddFilter(new P2PSocketDispatcherHost(
+  p2p_socket_dispatcher_host_ = new P2PSocketDispatcherHost(
       resource_context,
-      browser_context->GetRequestContextForRenderProcess(GetID())));
+      browser_context->GetRequestContextForRenderProcess(GetID()),
+      GetID());
+  AddFilter(p2p_socket_dispatcher_host_);
 #endif
 
   AddFilter(new TraceMessageFilter());
   AddFilter(new ResolveProxyMsgHelper(
       browser_context->GetRequestContextForRenderProcess(GetID())));
   AddFilter(new QuotaDispatcherHost(
       GetID(),
       storage_partition_impl_->GetQuotaManager(),
       GetContentClient()->browser()->CreateQuotaPermissionContext()));
   AddFilter(new GamepadBrowserMessageFilter());
@@ skipping 682 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DisableAecDumpOnFileThread),
       base::Bind(&RenderProcessHostImpl::SendDisableAecDumpToRenderer,
                  weak_factory_.GetWeakPtr()));
 }
 
 void RenderProcessHostImpl::SetWebRtcLogMessageCallback(
     base::Callback<void(const std::string&)> callback) {
   webrtc_log_message_callback_ = callback;
 }
+
+void RenderProcessHostImpl::SetWebRtcRtpPacketCallback(
+    const WebRtcRtpPacketCallback& callback) {
+  webrtc_rtp_packet_callback_ = callback;
+}
+
+void RenderProcessHostImpl::StartRtpDump(bool incoming, bool outgoing) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&P2PSocketDispatcherHost::StartRtpDump,
+                                     p2p_socket_dispatcher_host_,
+                                     incoming,
+                                     outgoing));
+}
+
+void RenderProcessHostImpl::StopRtpDump(bool incoming, bool outgoing) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(&P2PSocketDispatcherHost::StopRtpDump,
+                                     p2p_socket_dispatcher_host_,
+                                     incoming,
+                                     outgoing));
+}
+
 #endif
 
 IPC::ChannelProxy* RenderProcessHostImpl::GetChannel() {
   return channel_.get();
 }
 
 void RenderProcessHostImpl::AddFilter(BrowserMessageFilter* filter) {
   channel_->AddFilter(filter->GetFilter());
 }
 
@@ skipping 367 matching lines @@
       gpu_message_filter_,
       route_id));
 }
 
 #if defined(ENABLE_WEBRTC)
 void RenderProcessHostImpl::WebRtcLogMessage(const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!webrtc_log_message_callback_.is_null())
     webrtc_log_message_callback_.Run(message);
 }
+
+void RenderProcessHostImpl::OnRtpPacket(const uint8* packet_header,
+                                        size_t header_length,
+                                        size_t packet_length,
+                                        bool incoming) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!webrtc_rtp_packet_callback_.is_null())
+    webrtc_rtp_packet_callback_.Run(
+        packet_header, header_length, packet_length, incoming);
+}
 #endif
 
 scoped_refptr<ScreenOrientationDispatcherHost>
 RenderProcessHostImpl::screen_orientation_dispatcher_host() const {
   return make_scoped_refptr(screen_orientation_dispatcher_host_);
 }
 
 void RenderProcessHostImpl::OnShutdownRequest() {
   // Don't shut down if there are active RenderViews, or if there are pending
   // RenderViews being swapped back in.
@@ skipping 163 matching lines @@
     mojo::ScopedMessagePipeHandle handle) {
   mojo_activation_required_ = true;
   MaybeActivateMojo();
 
   mojo::AllocationScope scope;
   mojo_application_host_->shell_client()->AcceptConnection(service_name,
                                                            handle.Pass());
 }
 
 }  // namespace content