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

talk/media/base/fakemediaengine.h

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 57 matching lines @@
   bool playout() const { return playout_; }
   const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
   const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
 
   bool SendRtp(const void* data, int len) {
     if (!sending_) {
       return false;
     }
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len,
                        kMaxRtpPacketLen);
-    return Base::SendPacket(&packet);
+    return Base::SendPacket(&packet, rtc::PacketOptions());
   }
   bool SendRtcp(const void* data, int len) {
     rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len,
                        kMaxRtpPacketLen);
-    return Base::SendRtcp(&packet);
+    return Base::SendRtcp(&packet, rtc::PacketOptions());
   }
 
   bool CheckRtp(const void* data, int len) {
     bool success = !rtp_packets_.empty();
     if (success) {
       std::string packet = rtp_packets_.front();
       rtp_packets_.pop_front();
       success = (packet == std::string(static_cast<const char*>(data), len));
     }
     return success;
@@ skipping 63 matching lines @@
   }
 
   // TODO(perkj): This is to support legacy unit test that only check one
   // sending stream.
   const std::string rtcp_cname() {
     if (send_streams_.empty())
       return "";
     return send_streams_[0].cname;
   }
 
+  rtc::SentPacket last_sent_packet() const { return last_sent_packet_; }
+
   bool ready_to_send() const {
     return ready_to_send_;
   }
 
  protected:
   bool MuteStream(uint32 ssrc, bool mute) {
     if (!HasSendStream(ssrc) && ssrc != 0) {
       return false;
     }
     if (mute) {
@@ skipping 19 matching lines @@
     return true;
   }
   virtual void OnPacketReceived(rtc::Buffer* packet,
                                 const rtc::PacketTime& packet_time) {
     rtp_packets_.push_back(std::string(packet->data<char>(), packet->size()));
   }
   virtual void OnRtcpReceived(rtc::Buffer* packet,
                               const rtc::PacketTime& packet_time) {
     rtcp_packets_.push_back(std::string(packet->data<char>(), packet->size()));
   }
+  virtual void OnSentPacket(const rtc::SentPacket& sent_packet) {
+    last_sent_packet_ = sent_packet;
+  }
   virtual void OnReadyToSend(bool ready) {
     ready_to_send_ = ready;
   }
   bool fail_set_send_codecs() const { return fail_set_send_codecs_; }
   bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
 
  private:
   bool sending_;
   bool playout_;
   std::vector<RtpHeaderExtension> recv_extensions_;
   std::vector<RtpHeaderExtension> send_extensions_;
   std::list<std::string> rtp_packets_;
   std::list<std::string> rtcp_packets_;
   std::vector<StreamParams> send_streams_;
   std::vector<StreamParams> receive_streams_;
   std::set<uint32> muted_streams_;
   bool fail_set_send_codecs_;
   bool fail_set_recv_codecs_;
   uint32 send_ssrc_;
   std::string rtcp_cname_;
+  rtc::SentPacket last_sent_packet_;
   bool ready_to_send_;
 };
 
 class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
  public:
   struct DtmfInfo {
     DtmfInfo(uint32 ssrc, int event_code, int duration, int flags)
         : ssrc(ssrc), event_code(event_code), duration(duration), flags(flags) {
     }
     uint32 ssrc;
@@ skipping 767 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_