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

talk/media/base/mediachannel.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 486 matching lines @@
 enum DtmfFlags {
   DF_PLAY = 0x01,
   DF_SEND = 0x02,
 };
 
 class MediaChannel : public sigslot::has_slots<> {
  public:
   class NetworkInterface {
    public:
     enum SocketType { ST_RTP, ST_RTCP };
-    virtual bool SendPacket(
-        rtc::Buffer* packet,
-        rtc::DiffServCodePoint dscp = rtc::DSCP_NO_CHANGE) = 0;
-    virtual bool SendRtcp(
-        rtc::Buffer* packet,
-        rtc::DiffServCodePoint dscp = rtc::DSCP_NO_CHANGE) = 0;
+    virtual bool SendPacket(rtc::Buffer* packet,
+                            const rtc::PacketOptions& options) = 0;
+    virtual bool SendRtcp(rtc::Buffer* packet,
+                          const rtc::PacketOptions& options) = 0;
     virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                           int option) = 0;
     virtual ~NetworkInterface() {}
   };
 
   MediaChannel() : network_interface_(NULL) {}
   virtual ~MediaChannel() {}
 
   // Sets the abstract interface class for sending RTP/RTCP data.
   virtual void SetInterface(NetworkInterface *iface) {
@@ skipping 23 matching lines @@
   // ssrc must be the first SSRC of the media stream if the stream uses
   // multiple SSRCs.
   virtual bool RemoveRecvStream(uint32_t ssrc) = 0;
 
   // Returns the absoulte sendtime extension id value from media channel.
   virtual int GetRtpSendTimeExtnId() const {
     return -1;
   }
 
   // Base method to send packet using NetworkInterface.
-  bool SendPacket(rtc::Buffer* packet) {
-    return DoSendPacket(packet, false);
+  bool SendPacket(rtc::Buffer* packet, const rtc::PacketOptions& options) {
+    return DoSendPacket(packet, false, options);
   }
 
-  bool SendRtcp(rtc::Buffer* packet) {
-    return DoSendPacket(packet, true);
+  bool SendRtcp(rtc::Buffer* packet, const rtc::PacketOptions& options) {
+    return DoSendPacket(packet, true, options);
   }
 
   int SetOption(NetworkInterface::SocketType type,
                 rtc::Socket::Option opt,
                 int option) {
     rtc::CritScope cs(&network_interface_crit_);
     if (!network_interface_)
       return -1;
 
     return network_interface_->SetOption(type, opt, option);
   }
 
  protected:
   // This method sets DSCP |value| on both RTP and RTCP channels.
   int SetDscp(rtc::DiffServCodePoint value) {
     int ret;
     ret = SetOption(NetworkInterface::ST_RTP,
                     rtc::Socket::OPT_DSCP,
                     value);
     if (ret == 0) {
       ret = SetOption(NetworkInterface::ST_RTCP,
                       rtc::Socket::OPT_DSCP,
                       value);
     }
     return ret;
   }
 
  private:
-  bool DoSendPacket(rtc::Buffer* packet, bool rtcp) {
+  bool DoSendPacket(rtc::Buffer* packet,
+                    bool rtcp,
+                    const rtc::PacketOptions& options) {
     rtc::CritScope cs(&network_interface_crit_);
     if (!network_interface_)
       return false;
 
-    return (!rtcp) ? network_interface_->SendPacket(packet) :
-                     network_interface_->SendRtcp(packet);
+    return (!rtcp) ? network_interface_->SendPacket(packet, options)
+                   : network_interface_->SendRtcp(packet, options);
   }
 
   // |network_interface_| can be accessed from the worker_thread and
   // from any MediaEngine threads. This critical section is to protect accessing
   // of network_interface_ object.
   rtc::CriticalSection network_interface_crit_;
   NetworkInterface* network_interface_;
 };
 
 enum SendFlags {
@@ skipping 653 matching lines @@
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_