1 files changed, 97 insertions, 21 deletions

diff --git a/chromium/content/browser/renderer_host/p2p/socket_dispatcher_host.cc b/chromium/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
index 1608ae0f40c..bb8c1fb9610 100644
--- a/chromium/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
+++ b/chromium/content/browser/renderer_host/p2p/socket_dispatcher_host.cc
@@ -26,7 +26,7 @@ const size_t kMaximumPacketSize = 32768;
 
 class P2PSocketDispatcherHost::DnsRequest {
  public:
-  typedef base::Callback<void(const net::IPAddressNumber&)> DoneCallback;
+  typedef base::Callback<void(const net::IPAddressList&)> DoneCallback;
 
   DnsRequest(int32 request_id, net::HostResolver* host_resolver)
       : request_id_(request_id),
@@ -42,7 +42,8 @@ class P2PSocketDispatcherHost::DnsRequest {
 
     // Return an error if it's an empty string.
     if (host_name_.empty()) {
-      done_callback_.Run(net::IPAddressNumber());
+      net::IPAddressList address_list;
+      done_callback_.Run(address_list);
       return;
     }
 
@@ -67,15 +68,20 @@ class P2PSocketDispatcherHost::DnsRequest {
 
  private:
   void OnDone(int result) {
+    net::IPAddressList list;
     if (result != net::OK) {
       LOG(ERROR) << "Failed to resolve address for " << host_name_
                  << ", errorcode: " << result;
-      done_callback_.Run(net::IPAddressNumber());
+      done_callback_.Run(list);
       return;
     }
 
     DCHECK(!addresses_.empty());
-    done_callback_.Run(addresses_.front().address());
+    for (net::AddressList::iterator iter = addresses_.begin();
+         iter != addresses_.end(); ++iter) {
+      list.push_back(iter->address());
+    }
+    done_callback_.Run(list);
   }
 
   int32 request_id_;
@@ -90,13 +96,16 @@ class P2PSocketDispatcherHost::DnsRequest {
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
     content::ResourceContext* resource_context,
     net::URLRequestContextGetter* url_context)
-    : resource_context_(resource_context),
+    : BrowserMessageFilter(P2PMsgStart),
+      resource_context_(resource_context),
       url_context_(url_context),
-      monitoring_networks_(false) {
+      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.
+  // Since the IPC sender is gone, close pending connections.
   STLDeleteContainerPairSecondPointers(sockets_.begin(), sockets_.end());
   sockets_.clear();
 
@@ -113,10 +122,9 @@ void P2PSocketDispatcherHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
-bool P2PSocketDispatcherHost::OnMessageReceived(const IPC::Message& message,
-                                                bool* message_was_ok) {
+bool P2PSocketDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP_EX(P2PSocketDispatcherHost, message, *message_was_ok)
+  IPC_BEGIN_MESSAGE_MAP(P2PSocketDispatcherHost, message)
     IPC_MESSAGE_HANDLER(P2PHostMsg_StartNetworkNotifications,
                         OnStartNetworkNotifications)
     IPC_MESSAGE_HANDLER(P2PHostMsg_StopNetworkNotifications,
@@ -126,9 +134,10 @@ bool P2PSocketDispatcherHost::OnMessageReceived(const IPC::Message& message,
     IPC_MESSAGE_HANDLER(P2PHostMsg_AcceptIncomingTcpConnection,
                         OnAcceptIncomingTcpConnection)
     IPC_MESSAGE_HANDLER(P2PHostMsg_Send, OnSend)
+    IPC_MESSAGE_HANDLER(P2PHostMsg_SetOption, OnSetOption)
     IPC_MESSAGE_HANDLER(P2PHostMsg_DestroySocket, OnDestroySocket)
     IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP_EX()
+  IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ -139,6 +148,38 @@ void P2PSocketDispatcherHost::OnIPAddressChanged() {
           &P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
+void P2PSocketDispatcherHost::StartRtpDump(
+    bool incoming,
+    bool outgoing,
+    const RenderProcessHost::WebRtcRtpPacketCallback& packet_callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if ((!dump_incoming_rtp_packet_ && incoming) ||
+      (!dump_outgoing_rtp_packet_ && outgoing)) {
+    if (incoming)
+      dump_incoming_rtp_packet_ = true;
+
+    if (outgoing)
+      dump_outgoing_rtp_packet_ = true;
+
+    packet_callback_ = packet_callback;
+    for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
+      it->second->StartRtpDump(incoming, outgoing, packet_callback);
+  }
+}
+
+void P2PSocketDispatcherHost::StopRtpDumpOnUIThread(bool incoming,
+                                                    bool outgoing) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&P2PSocketDispatcherHost::StopRtpDumpOnIOThread,
+                 this,
+                 incoming,
+                 outgoing));
+}
+
 P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
   DCHECK(sockets_.empty());
   DCHECK(dns_requests_.empty());
@@ -152,8 +193,7 @@ P2PSocketHost* P2PSocketDispatcherHost::LookupSocket(int socket_id) {
   return (it == sockets_.end()) ? NULL : it->second;
 }
 
-void P2PSocketDispatcherHost::OnStartNetworkNotifications(
-    const IPC::Message& msg) {
+void P2PSocketDispatcherHost::OnStartNetworkNotifications() {
   if (!monitoring_networks_) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
     monitoring_networks_ = true;
@@ -164,8 +204,7 @@ void P2PSocketDispatcherHost::OnStartNetworkNotifications(
           &P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
-void P2PSocketDispatcherHost::OnStopNetworkNotifications(
-    const IPC::Message& msg) {
+void P2PSocketDispatcherHost::OnStopNetworkNotifications() {
   if (monitoring_networks_) {
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
     monitoring_networks_ = false;
@@ -185,7 +224,7 @@ void P2PSocketDispatcherHost::OnGetHostAddress(const std::string& host_name,
 void P2PSocketDispatcherHost::OnCreateSocket(
     P2PSocketType type, int socket_id,
     const net::IPEndPoint& local_address,
-    const net::IPEndPoint& remote_address) {
+    const P2PHostAndIPEndPoint& remote_address) {
   if (LookupSocket(socket_id)) {
     LOG(ERROR) << "Received P2PHostMsg_CreateSocket for socket "
         "that already exists.";
@@ -202,6 +241,12 @@ void P2PSocketDispatcherHost::OnCreateSocket(
 
   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_,
+                                        packet_callback_);
+    }
   }
 }
 
@@ -224,7 +269,7 @@ void P2PSocketDispatcherHost::OnAcceptIncomingTcpConnection(
 void P2PSocketDispatcherHost::OnSend(int socket_id,
                                      const net::IPEndPoint& socket_address,
                                      const std::vector<char>& data,
-                                     net::DiffServCodePoint dscp,
+                                     const talk_base::PacketOptions& options,
                                      uint64 packet_id) {
   P2PSocketHost* socket = LookupSocket(socket_id);
   if (!socket) {
@@ -241,7 +286,19 @@ void P2PSocketDispatcherHost::OnSend(int socket_id,
     return;
   }
 
-  socket->Send(socket_address, data, dscp, packet_id);
+  socket->Send(socket_address, data, options, packet_id);
+}
+
+void P2PSocketDispatcherHost::OnSetOption(int socket_id,
+                                          P2PSocketOption option,
+                                          int value) {
+  P2PSocketHost* socket = LookupSocket(socket_id);
+  if (!socket) {
+    LOG(ERROR) << "Received P2PHostMsg_SetOption for invalid socket_id.";
+    return;
+  }
+
+  socket->SetOption(option, value);
 }
 
 void P2PSocketDispatcherHost::OnDestroySocket(int socket_id) {
@@ -256,7 +313,8 @@ void P2PSocketDispatcherHost::OnDestroySocket(int socket_id) {
 
 void P2PSocketDispatcherHost::DoGetNetworkList() {
   net::NetworkInterfaceList list;
-  net::GetNetworkList(&list);
+  net::GetNetworkList(&list, net::EXCLUDE_HOST_SCOPE_VIRTUAL_INTERFACES |
+                             net::INCLUDE_ONLY_TEMP_IPV6_ADDRESS_IF_POSSIBLE);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(
           &P2PSocketDispatcherHost::SendNetworkList, this, list));
@@ -269,11 +327,29 @@ void P2PSocketDispatcherHost::SendNetworkList(
 
 void P2PSocketDispatcherHost::OnAddressResolved(
     DnsRequest* request,
-    const net::IPAddressNumber& result) {
-  Send(new P2PMsg_GetHostAddressResult(request->request_id(), result));
+    const net::IPAddressList& addresses) {
+  Send(new P2PMsg_GetHostAddressResult(request->request_id(), addresses));
 
   dns_requests_.erase(request);
   delete request;
 }
 
+void P2PSocketDispatcherHost::StopRtpDumpOnIOThread(bool incoming,
+                                                    bool outgoing) {
+  if ((dump_incoming_rtp_packet_ && incoming) ||
+      (dump_outgoing_rtp_packet_ && outgoing)) {
+    if (incoming)
+      dump_incoming_rtp_packet_ = false;
+
+    if (outgoing)
+      dump_outgoing_rtp_packet_ = false;
+
+    if (!dump_incoming_rtp_packet_ && !dump_outgoing_rtp_packet_)
+      packet_callback_.Reset();
+
+    for (SocketsMap::iterator it = sockets_.begin(); it != sockets_.end(); ++it)
+      it->second->StopRtpDump(incoming, outgoing);
+  }
+}
+
 }  // namespace content