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

webrtc/p2p/base/relayport.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include <algorithm>
@@ skipping 126 matching lines @@
   // Called when a TCP connection is established or fails
   void OnSocketConnect(rtc::AsyncPacketSocket* socket);
   void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
 
   // Called when a packet is received on this socket.
   void OnReadPacket(
     rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time);
+
+  void OnSentPacket(rtc::AsyncPacketSocket* socket,
+                    const rtc::SentPacket& sent_packet);
+
   // Called when the socket is currently able to send.
   void OnReadyToSend(rtc::AsyncPacketSocket* socket);
 
   // Sends the given data on the socket to the server with no wrapping.  This
   // returns the number of bytes written or -1 if an error occurred.
   int SendPacket(const void* data, size_t size,
                  const rtc::PacketOptions& options);
 };
 
 // Handles an allocate request for a particular RelayEntry.
@@ skipping 337 matching lines @@
   }
 
   // If we failed to get a socket, move on to the next protocol.
   if (!socket) {
     port()->thread()->Post(this, kMessageConnectTimeout);
     return;
   }
 
   // Otherwise, create the new connection and configure any socket options.
   socket->SignalReadPacket.connect(this, &RelayEntry::OnReadPacket);
+  socket->SignalSentPacket.connect(this, &RelayEntry::OnSentPacket);
   socket->SignalReadyToSend.connect(this, &RelayEntry::OnReadyToSend);
   current_connection_ = new RelayConnection(ra, socket, port()->thread());
   for (size_t i = 0; i < port_->options().size(); ++i) {
     current_connection_->SetSocketOption(port_->options()[i].first,
                                          port_->options()[i].second);
   }
 
   // If we're trying UDP, start binding requests.
   // If we're trying TCP, wait for connection with a fixed timeout.
   if ((ra->proto == PROTO_TCP) || (ra->proto == PROTO_SSLTCP)) {
@@ skipping 219 matching lines @@
   if (!data_attr) {
     LOG(INFO) << "Data indication has no data";
     return;
   }
 
   // Process the actual data and remote address in the normal manner.
   port_->OnReadPacket(data_attr->bytes(), data_attr->length(), remote_addr2,
                       PROTO_UDP, packet_time);
 }
 
+void RelayEntry::OnSentPacket(rtc::AsyncPacketSocket* socket,
+                              const rtc::SentPacket& sent_packet) {
+  port_->OnSentPacket(sent_packet);
+}
+
 void RelayEntry::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   if (connected()) {
     port_->OnReadyToSend();
   }
 }
 
 int RelayEntry::SendPacket(const void* data, size_t size,
                            const rtc::PacketOptions& options) {
   int sent = 0;
   if (current_connection_) {
@@ skipping 67 matching lines @@
   if (rtc::TimeSince(start_time_) <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
 void AllocateRequest::OnTimeout() {
   LOG(INFO) << "Allocate request timed out";
   entry_->HandleConnectFailure(connection_->socket());
 }
 
 }  // namespace cricket