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

webrtc/p2p/base/port.h

 /*
  *  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.
  */
 
@@ skipping 257 matching lines @@
   bool ParseStunUsername(const StunMessage* stun_msg,
                          std::string* local_username,
                          std::string* remote_username) const;
   void CreateStunUsername(const std::string& remote_username,
                           std::string* stun_username_attr_str) const;
 
   bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
                             IceMessage* stun_msg,
                             const std::string& remote_ufrag);
 
+  // Called when a packet has been sent to the socket.
+  void OnPacketSent(const rtc::SocketAddress& addr,
+                    const rtc::SentPacket& sent_packet);
+
   // Called when the socket is currently able to send.
   void OnReadyToSend();
 
   // Called when the Connection discovers a local peer reflexive candidate.
   // Returns the index of the new local candidate.
   size_t AddPrflxCandidate(const Candidate& local);
 
   void set_candidate_filter(uint32 candidate_filter) {
     candidate_filter_ = candidate_filter;
   }
@@ skipping 180 matching lines @@
   // covers.
   virtual int Send(const void* data, size_t size,
                    const rtc::PacketOptions& options) = 0;
 
   // Error if Send() returns < 0
   virtual int GetError() = 0;
 
   sigslot::signal4<Connection*, const char*, size_t, const rtc::PacketTime&>
       SignalReadPacket;
 
+  sigslot::signal2<Connection*, const rtc::SentPacket&> SignalSentPacket;
+
   sigslot::signal1<Connection*> SignalReadyToSend;
 
   // Called when a packet is received on this connection.
   void OnReadPacket(const char* data, size_t size,
                     const rtc::PacketTime& packet_time);
 
+  void OnPacketSent(const rtc::SentPacket& sent_packet);
+
   // Called when the socket is currently able to send.
   void OnReadyToSend();
 
   // Called when a connection is determined to be no longer useful to us.  We
   // still keep it around in case the other side wants to use it.  But we can
   // safely stop pinging on it and we can allow it to time out if the other
   // side stops using it as well.
   bool pruned() const { return pruned_; }
   void Prune();
 
@@ skipping 141 matching lines @@
                    const rtc::PacketOptions& options);
   virtual int GetError() { return error_; }
 
  private:
   int error_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_BASE_PORT_H_