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

talk/session/media/channel.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 195 matching lines @@
   virtual bool SendRtcp(rtc::Buffer* packet,
                         rtc::DiffServCodePoint dscp);
 
   // From TransportChannel
   void OnWritableState(TransportChannel* channel);
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data,
                              size_t len,
                              const rtc::PacketTime& packet_time,
                              int flags);
+  void OnPacketSent(TransportChannel* channel,
+                    const rtc::SentPacket& packet_sent);
   void OnReadyToSend(TransportChannel* channel);
 
   bool PacketIsRtcp(const TransportChannel* channel, const char* data,
                     size_t len);
   bool SendPacket(bool rtcp, rtc::Buffer* packet,
                   rtc::DiffServCodePoint dscp);
   virtual bool WantsPacket(bool rtcp, rtc::Buffer* packet);
   void HandlePacket(bool rtcp, rtc::Buffer* packet,
                     const rtc::PacketTime& packet_time);
 
@@ skipping 28 matching lines @@
                                  ContentAction action,
                                  std::string* error_desc) = 0;
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc) = 0;
   bool SetRtpTransportParameters_w(const MediaContentDescription* content,
                                    ContentAction action,
                                    ContentSource src,
                                    std::string* error_desc);
 
-  // Helper method to get RTP Absoulute SendTime extension header id if
-  // present in remote supported extensions list.
-  void MaybeCacheRtpAbsSendTimeHeaderExtension(
-    const std::vector<RtpHeaderExtension>& extensions);
+  // Helper method to store a subset of the RTP header extensions, if
+  // present in the remote supported extensions list.
+  void MaybeCacheRtpHeaderExtensions(
+      const std::vector<RtpHeaderExtension>& extensions);
 
   bool CheckSrtpConfig(const std::vector<CryptoParams>& cryptos,
                        bool* dtls,
                        std::string* error_desc);
   bool SetSrtp_w(const std::vector<CryptoParams>& params,
                  ContentAction action,
                  ContentSource src,
                  std::string* error_desc);
   void ActivateRtcpMux_w();
   bool SetRtcpMux_w(bool enable,
@@ skipping 10 matching lines @@
   virtual void OnConnectionMonitorUpdate(ConnectionMonitor* monitor,
       const std::vector<ConnectionInfo>& infos) = 0;
 
   // Helper function for invoking bool-returning methods on the worker thread.
   template <class FunctorT>
   bool InvokeOnWorker(const FunctorT& functor) {
     return worker_thread_->Invoke<bool>(functor);
   }
 
  private:
+  int32_t ParseTransportSequenceNumberHeaderExtension(uint8_t* data,
+                                                      size_t length) const;
+
   rtc::Thread* worker_thread_;
   TransportController* transport_controller_;
   MediaChannel* media_channel_;
   std::vector<StreamParams> local_streams_;
   std::vector<StreamParams> remote_streams_;
 
   const std::string content_name_;
   std::string transport_name_;
   bool rtcp_transport_enabled_;
   TransportChannel* transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > socket_options_;
   TransportChannel* rtcp_transport_channel_;
   std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_;
   SrtpFilter srtp_filter_;
   RtcpMuxFilter rtcp_mux_filter_;
   BundleFilter bundle_filter_;
   rtc::scoped_ptr<ConnectionMonitor> connection_monitor_;
   bool enabled_;
   bool writable_;
   bool rtp_ready_to_send_;
   bool rtcp_ready_to_send_;
   bool was_ever_writable_;
   MediaContentDirection local_content_direction_;
   MediaContentDirection remote_content_direction_;
   bool has_received_packet_;
   bool dtls_keyed_;
   bool secure_required_;
   int rtp_abs_sendtime_extn_id_;
+  int rtp_transport_sequence_number_extn_id_;
 };
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* thread,
                MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel,
                TransportController* transport_controller,
@@ skipping 322 matching lines @@
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_