Wire up transport sequence number / send time callbacks to webrtc via libjingle.

webrtc/base/asyncudpsocket.cc

Index: webrtc/base/asyncudpsocket.cc
diff --git a/webrtc/base/asyncudpsocket.cc b/webrtc/base/asyncudpsocket.cc
index 3e2ecc4cda487697f6dbcef8c30590a9bec24a2e..28c54dfce54b2b829cc845774d4130977fe813fd 100644
--- a/webrtc/base/asyncudpsocket.cc
+++ b/webrtc/base/asyncudpsocket.cc
@@ -60,13 +60,19 @@ SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
 
 int AsyncUDPSocket::Send(const void *pv, size_t cb,
                          const rtc::PacketOptions& options) {
-  return socket_->Send(pv, cb);
+  int ret = socket_->Send(pv, cb);

[pbos-webrtc, 2015/10/12 20:48:00]

This has the downside of you technically being able to receive a response from a
well-behaving client before SignalSentPacket gets triggered. Do you want to take
the timestamp before Send()? That has other downsides though (such as not
accounting for time within Send()).

[pthatcher1, 2015/10/13 05:31:13]

What do you mean "receive a response"?  Do you mean a packet from the remote
side sent back in response to the packet sent here?  I think whatever algorithm
uses these timestamps at the end of the day should take into account that the
timestamp might be after.   That's just how things goes with concurrent
operations.

However, if you really want to be safe with what we stick in SignalSentPacket,
we could put in two timestamps:  before and after.  Then the algorithm that uses
the timestamps could always pick which one it wants and even detect when there's
a large gap.

[stefan-webrtc, 2015/10/13 08:09:20]

I'll take the timestamp before Send() as that is what I'm doing in Chrome,
otherwise I agree with pthatcher.

[pbos-webrtc, 2015/10/15 09:51:49]

Yeah, you'd need the signal to be sent before sending the packet for this to
work that way. That'd possibly add latency, so I'd avoid that.

[stefan-webrtc, 2015/10/15 10:09:32]

Yes, agree.

+  rtc::SentPacket sent_packet(options.packet_id, rtc::Time());
+  SignalSentPacket(this, sent_packet);
+  return ret;
 }
 
 int AsyncUDPSocket::SendTo(const void *pv, size_t cb,
                            const SocketAddress& addr,
                            const rtc::PacketOptions& options) {
-  return socket_->SendTo(pv, cb, addr);
+  int ret = socket_->SendTo(pv, cb, addr);
+  rtc::SentPacket sent_packet(options.packet_id, rtc::Time());
+  SignalSentPacket(this, sent_packet);
+  return ret;
 }
 
 int AsyncUDPSocket::Close() {