Only initialize usrsctp when it's used and uninitialize when it's not being used.

webrtc/media/sctp/sctpdataengine.h

 /*
  *  Copyright (c) 2012 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.
  */
 
 #ifndef WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_
 #define WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_
 
 #include <errno.h>
 #include <string>
 #include <vector>
 
 namespace cricket {
 // Some ERRNO values get re-#defined to WSA* equivalents in some talk/
 // headers.  We save the original ones in an enum.
 enum PreservedErrno {
   SCTP_EINPROGRESS = EINPROGRESS,
   SCTP_EWOULDBLOCK = EWOULDBLOCK
 };
 }  // namespace cricket
 
 #include "webrtc/base/copyonwritebuffer.h"
+#include "webrtc/base/gtest_prod_util.h"
+#include "webrtc/base/thread_checker.h"
 #include "webrtc/media/base/codec.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/mediaengine.h"
 
 // Defined by "usrsctplib/usrsctp.h"
 struct sockaddr_conn;
 struct sctp_assoc_change;
 struct sctp_stream_reset_event;
 // Defined by <sys/socket.h>
 struct socket;
@@ skipping 30 matching lines @@
 // [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, public sigslot::has_slots<> {
  public:
   SctpDataEngine();
-  virtual ~SctpDataEngine();
+  ~SctpDataEngine() override;
 
-  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);
+  DataMediaChannel* CreateChannel(DataChannelType data_channel_type) override;
+  const std::vector<DataCodec>& data_codecs() override;
 
  private:
-  static int usrsctp_engines_count;
-  std::vector<DataCodec> codecs_;
-
-  static SctpDataMediaChannel* GetChannelFromSocket(struct socket* sock);
+  rtc::ThreadChecker thread_checker_;
+  const std::vector<DataCodec> codecs_;
 };
 
 // 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 53 matching lines @@
   rtc::Thread* worker_thread() const { return worker_thread_; }
 
   // Many of these things are unused by SCTP, but are needed to fulfill
   // the MediaChannel interface.
   virtual void OnRtcpReceived(rtc::CopyOnWriteBuffer* 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) {
+  void set_debug_name_for_testing(const char* debug_name) {
     debug_name_ = debug_name;
   }
-  const std::string& debug_name() const { return debug_name_; }
   const struct socket* socket() const { return sock_; }
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(SctpDataMediaChannelTest, EngineSignalsRightChannel);
+  static int SendThresholdCallback(struct socket* sock, uint32_t sb_free);
+  static SctpDataMediaChannel* GetChannelFromSocket(struct socket* sock);
+
  private:
   sockaddr_conn GetSctpSockAddr(int port);
 
   bool SetSendCodecs(const std::vector<DataCodec>& codecs);
   bool SetRecvCodecs(const std::vector<DataCodec>& codecs);
 
   // Creates the socket and connects. Sets sending_ to true.
   bool Connect();
   // Closes the socket. Sets sending_ to false.
   void Disconnect();
@@ skipping 43 matching lines @@
   // want to close it, the stream's ID goes into queued_reset_streams_.  When
   // we actually transmit a RE-CONFIG chunk with that stream ID, the ID goes
   // into sent_reset_streams_.  When we get a response RE-CONFIG chunk back
   // acknowledging the reset, we remove the stream ID from
   // sent_reset_streams_.  We use sent_reset_streams_ to differentiate
   // between acknowledgment RE-CONFIG and peer-initiated RE-CONFIGs.
   StreamSet open_streams_;
   StreamSet queued_reset_streams_;
   StreamSet sent_reset_streams_;
 
-  // A human-readable name for debugging messages.
-  std::string debug_name_;
+  // A static human-readable name for debugging messages.
+  const char* debug_name_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_SCTP_SCTPDATAENGINE_H_