Wire up transport sequence number and send time.

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/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
@@ skipping 273 matching lines @@
     if (result == net::OK) {
       last_dscp_ = dscp;
     } else if (!IsTransientError(result) && last_dscp_ != net::DSCP_CS0) {
       // We receieved a non-transient error, and it seems we have
       // not changed the DSCP in the past, disable DSCP as it unlikely
       // to work in the future.
       last_dscp_ = net::DSCP_NO_CHANGE;
     }
   }
 
-  uint64 tick_received = base::TimeTicks::Now().ToInternalValue();
+  base::TimeTicks time_received = base::TimeTicks::Now();
 
   packet_processing_helpers::ApplyPacketOptions(
       packet.data->data(), packet.size, packet.packet_options, 0);
-  int result = socket_->SendTo(packet.data.get(),
-                               packet.size,
-                               packet.to,
-                               base::Bind(&P2PSocketHostUdp::OnSend,
-                                          base::Unretained(this),
-                                          packet.id,
-                                          tick_received));
+  auto callback_binding = base::Bind(
+      &P2PSocketHostUdp::OnSend, base::Unretained(this), packet.id,
+      packet.packet_options.transport_sequence_number, time_received);
+  int result = socket_->SendTo(packet.data.get(), packet.size, packet.to,
+                               callback_binding);
 
   // sendto() may return an error, e.g. if we've received an ICMP Destination
   // Unreachable message. When this happens try sending the same packet again,
   // and just drop it if it fails again.
   if (IsTransientError(result)) {
-    result = socket_->SendTo(packet.data.get(),
-                             packet.size,
-                             packet.to,
-                             base::Bind(&P2PSocketHostUdp::OnSend,
-                                        base::Unretained(this),
-                                        packet.id,
-                                        tick_received));
+    result = socket_->SendTo(packet.data.get(), packet.size, packet.to,
+                             callback_binding);
   }
 
   if (result == net::ERR_IO_PENDING) {
     send_pending_ = true;
   } else {
-    HandleSendResult(packet.id, tick_received, result);
+    HandleSendResult(packet.id, packet.packet_options.transport_sequence_number,
+                     time_received, result);
   }
 
   if (dump_outgoing_rtp_packet_)
     DumpRtpPacket(packet.data->data(), packet.size, false);
 }
 
-void P2PSocketHostUdp::OnSend(uint64 packet_id,
-                              uint64 tick_received,
+void P2PSocketHostUdp::OnSend(uint64_t packet_id,
+                              int32_t transport_sequence_number,
+                              base::TimeTicks time_received,
                               int result) {
   DCHECK(send_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
-  HandleSendResult(packet_id, tick_received, result);
+  HandleSendResult(packet_id, transport_sequence_number, time_received, result);
 
   // Send next packets if we have them waiting in the buffer.
   while (state_ == STATE_OPEN && !send_queue_.empty() && !send_pending_) {
     PendingPacket packet = send_queue_.front();
     DoSend(packet);
     send_queue_.pop_front();
     DecrementDelayedBytes(packet.size);
   }
 }
 
-void P2PSocketHostUdp::HandleSendResult(uint64 packet_id,
-                                        uint64 tick_received,
+void P2PSocketHostUdp::HandleSendResult(uint64_t packet_id,
+                                        int32_t transport_sequence_number,
+                                        base::TimeTicks time_received,

[Sergey Ulanov, 2015/09/18 21:16:11]

Should this be called send_time, or something like that? time_received makes
little sense given that we are sending data here.

[Stefan, 2015/09/22 07:51:36]

I definitely agree. Changing.

                                         int result) {
   TRACE_EVENT_ASYNC_END1("p2p", "Send", packet_id,
                          "result", result);
   if (result < 0) {
     if (!IsTransientError(result)) {
       LOG(ERROR) << "Error when sending data in UDP socket: " << result;
       OnError();
       return;
     }
     VLOG(0) << "sendto() has failed twice returning a "
                " transient error " << GetTransientErrorName(result)
             << ". Dropping the packet.";
   }
 
   // UMA to track the histograms from 1ms to 1 sec for how long a packet spends
   // in the browser process.
-  UMA_HISTOGRAM_TIMES(
-      "WebRTC.SystemSendPacketDuration_UDP" /* name */,
-      base::TimeTicks::Now() -
-          base::TimeTicks::FromInternalValue(tick_received) /* sample */);
+  UMA_HISTOGRAM_TIMES("WebRTC.SystemSendPacketDuration_UDP" /* name */,
+                      base::TimeTicks::Now() - time_received /* sample */);
 
-  message_sender_->Send(
-      new P2PMsg_OnSendComplete(id_, P2PSendPacketMetrics(packet_id)));
+  message_sender_->Send(new P2PMsg_OnSendComplete(
+      id_, P2PSendPacketMetrics(packet_id, transport_sequence_number,
+                                time_received)));
 }
 
 P2PSocketHost* P2PSocketHostUdp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 bool P2PSocketHostUdp::SetOption(P2PSocketOption option, int value) {
@@ skipping 11 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