(try 2) Added send-thresholding and fixed text packet dumping

talk/media/sctp/sctpdataengine.h

 /*
  * libjingle
  * Copyright 2012 Google Inc. and Robin Seggelmann
  *
  * 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 46 matching lines @@
 // The highest stream ID (Sid) that SCTP allows, and the number of streams we
 // tell SCTP we're going to use.
 const uint32 kMaxSctpSid = 1023;
 
 // This is the default SCTP port to use. It is passed along the wire and the
 // connectee and connector must be using the same port. It is not related to the
 // ports at the IP level. (Corresponds to: sockaddr_conn.sconn_port in
 // usrsctp.h)
 const int kSctpDefaultPort = 5000;
 
+class SctpDataMediaChannel;
+
 // A DataEngine that interacts with usrsctp.
 //
 // From channel calls, data flows like this:
 // [worker thread (although it can in princple be another thread)]
 //  1.  SctpDataMediaChannel::SendData(data)
 //  2.  usrsctp_sendv(data)
 // [worker thread returns; sctp thread then calls the following]
 //  3.  OnSctpOutboundPacket(wrapped_data)
 // [sctp thread returns having posted a message for the worker thread]
 //  4.  SctpDataMediaChannel::OnMessage(wrapped_data)
 //  5.  SctpDataMediaChannel::OnPacketFromSctpToNetwork(wrapped_data)
 //  6.  NetworkInterface::SendPacket(wrapped_data)
 //  7.  ... across network ... a packet is sent back ...
 //  8.  SctpDataMediaChannel::OnPacketReceived(wrapped_data)
 //  9.  usrsctp_conninput(wrapped_data)
 // [worker thread returns; sctp thread then calls the following]
 //  10.  OnSctpInboundData(data)
 // [sctp thread returns having posted a message fot the worker thread]
 //  11. SctpDataMediaChannel::OnMessage(inboundpacket)
 //  12. SctpDataMediaChannel::OnInboundPacketFromSctpToChannel(inboundpacket)
 //  13. SctpDataMediaChannel::OnDataFromSctpToChannel(data)
 //  14. SctpDataMediaChannel::SignalDataReceived(data)
 // [from the same thread, methods registered/connected to
 //  SctpDataMediaChannel are called with the recieved data]
-class SctpDataEngine : public DataEngineInterface {
+class SctpDataEngine : public DataEngineInterface, public sigslot::has_slots<> {
  public:
   SctpDataEngine();
   virtual ~SctpDataEngine();
 
   virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type);
 
   virtual const std::vector<DataCodec>& data_codecs() { return codecs_; }
 
+  static int SendThresholdCallback(struct socket* sock, uint32_t sb_free);
+
  private:
   static int usrsctp_engines_count;
   std::vector<DataCodec> codecs_;
+
+  static SctpDataMediaChannel* GetChannelFromSocket(struct socket* sock);
 };
 
 // TODO(ldixon): Make into a special type of TypedMessageData.
 // Holds data to be passed on to a channel.
 struct SctpInboundPacket;
 
 class SctpDataMediaChannel : public DataMediaChannel,
                              public rtc::MessageHandler {
  public:
   // DataMessageType is used for the SCTP "Payload Protocol Identifier", as
@@ skipping 63 matching lines @@
   virtual bool SetRecvRtpHeaderExtensions(
       const std::vector<RtpHeaderExtension>& extensions) { return true; }
   virtual bool SetSendRtpHeaderExtensions(
       const std::vector<RtpHeaderExtension>& extensions) { return true; }
   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs);
   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
   virtual void OnRtcpReceived(rtc::Buffer* packet,
                               const rtc::PacketTime& packet_time) {}
   virtual void OnReadyToSend(bool ready) {}
 
+  void OnSendThresholdCallback();
   // Helper for debugging.
   void set_debug_name(const std::string& debug_name) {
     debug_name_ = debug_name;
   }
   const std::string& debug_name() const { return debug_name_; }
-
+  const struct socket* socket() const { return sock_; }
  private:
   sockaddr_conn GetSctpSockAddr(int port);
 
   // Creates the socket and connects. Sets sending_ to true.
   bool Connect();
   // Closes the socket. Sets sending_ to false.
   void Disconnect();
 
   // Returns false when openning the socket failed; when successfull sets
   // sending_ to true
@@ skipping 47 matching lines @@
   StreamSet queued_reset_streams_;
   StreamSet sent_reset_streams_;
 
   // A human-readable name for debugging messages.
   std::string debug_name_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_SCTP_SCTPDATAENGINE_H_