webrtc/media/sctp/sctpdataengine_unittest.cc - src - Git at Google

 /*
  *  Copyright (c) 2013 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.
  */

 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>

 #include <memory>
 #include <string>
 #include <vector>

 #include "webrtc/base/bind.h"
 #include "webrtc/base/copyonwritebuffer.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/messagehandler.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/sctp/sctpdataengine.h"

 namespace cricket {
 enum {
   MSG_PACKET = 1,
 };

 // Fake NetworkInterface that sends/receives sctp packets.  The one in
 // webrtc/media/base/fakenetworkinterface.h only works with rtp/rtcp.
 class SctpFakeNetworkInterface : public MediaChannel::NetworkInterface,
                                  public rtc::MessageHandler {
  public:
   explicit SctpFakeNetworkInterface(rtc::Thread* thread)
     : thread_(thread),
       dest_(NULL) {
   }

   void SetDestination(DataMediaChannel* dest) { dest_ = dest; }

  protected:
   // Called to send raw packet down the wire (e.g. SCTP an packet).
   virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
                           const rtc::PacketOptions& options) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket";

     rtc::CopyOnWriteBuffer* buffer = new rtc::CopyOnWriteBuffer(*packet);
     thread_->Post(RTC_FROM_HERE, this, MSG_PACKET,
                   rtc::WrapMessageData(buffer));
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket, Posted message.";
     return true;
   }

   // Called when a raw packet has been recieved. This passes the data to the
   // code that will interpret the packet. e.g. to get the content payload from
   // an SCTP packet.
   virtual void OnMessage(rtc::Message* msg) {
     LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::OnMessage";
     std::unique_ptr<rtc::CopyOnWriteBuffer> buffer(
         static_cast<rtc::TypedMessageData<rtc::CopyOnWriteBuffer*>*>(
             msg->pdata)->data());
     if (dest_) {
       dest_->OnPacketReceived(buffer.get(), rtc::PacketTime());
     }
     delete msg->pdata;
   }

   // Unsupported functions required to exist by NetworkInterface.
   // TODO(ldixon): Refactor parent NetworkInterface class so these are not
   // required. They are RTC specific and should be in an appropriate subclass.
   virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
                         const rtc::PacketOptions& options) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SendRtcp.";
     return false;
   }
   virtual int SetOption(SocketType type, rtc::Socket::Option opt,
                         int option) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
     return 0;
   }
   virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {
     LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
   }

  private:
   // Not owned by this class.
   rtc::Thread* thread_;
   DataMediaChannel* dest_;
 };

 // This is essentially a buffer to hold recieved data. It stores only the last
 // received data. Calling OnDataReceived twice overwrites old data with the
 // newer one.
 // TODO(ldixon): Implement constraints, and allow new data to be added to old
 // instead of replacing it.
 class SctpFakeDataReceiver : public sigslot::has_slots<> {
  public:
   SctpFakeDataReceiver() : received_(false) {}

   void Clear() {
     received_ = false;
     last_data_ = "";
     last_params_ = ReceiveDataParams();
   }

   virtual void OnDataReceived(const ReceiveDataParams& params,
                               const char* data,
                               size_t length) {
     received_ = true;
     last_data_ = std::string(data, length);
     last_params_ = params;
   }

   bool received() const { return received_; }
   std::string last_data() const { return last_data_; }
   ReceiveDataParams last_params() const { return last_params_; }

  private:
   bool received_;
   std::string last_data_;
   ReceiveDataParams last_params_;
 };

 class SignalReadyToSendObserver : public sigslot::has_slots<> {
  public:
   SignalReadyToSendObserver() : signaled_(false), writable_(false) {}

   void OnSignaled(bool writable) {
     signaled_ = true;
     writable_ = writable;
   }

   bool IsSignaled(bool writable) {
     return signaled_ && (writable_ == writable);
   }

  private:
   bool signaled_;
   bool writable_;
 };

 class SignalChannelClosedObserver : public sigslot::has_slots<> {
  public:
   SignalChannelClosedObserver() {}
   void BindSelf(SctpDataMediaChannel* channel) {
     channel->SignalStreamClosedRemotely.connect(
         this, &SignalChannelClosedObserver::OnStreamClosed);
   }
   void OnStreamClosed(uint32_t stream) { streams_.push_back(stream); }

   int StreamCloseCount(uint32_t stream) {
     return std::count(streams_.begin(), streams_.end(), stream);
   }

   bool WasStreamClosed(uint32_t stream) {
     return std::find(streams_.begin(), streams_.end(), stream)
         != streams_.end();
   }

  private:
   std::vector<uint32_t> streams_;
 };

 class SignalChannelClosedReopener : public sigslot::has_slots<> {
  public:
   SignalChannelClosedReopener(SctpDataMediaChannel* channel,
                               SctpDataMediaChannel* peer)
       : channel_(channel), peer_(peer) {}

   void OnStreamClosed(int stream) {
     StreamParams p(StreamParams::CreateLegacy(stream));
     channel_->AddSendStream(p);
     channel_->AddRecvStream(p);
     peer_->AddSendStream(p);
     peer_->AddRecvStream(p);
     streams_.push_back(stream);
   }

   int StreamCloseCount(int stream) {
     return std::count(streams_.begin(), streams_.end(), stream);
   }

  private:
   SctpDataMediaChannel* channel_;
   SctpDataMediaChannel* peer_;
   std::vector<int> streams_;
 };

 // SCTP Data Engine testing framework.
 class SctpDataMediaChannelTest : public testing::Test,
                                  public sigslot::has_slots<> {
  protected:
   // usrsctp uses the NSS random number generator on non-Android platforms,
   // so we need to initialize SSL.
   static void SetUpTestCase() {
   }

   virtual void SetUp() { engine_.reset(new SctpDataEngine()); }

   void SetupConnectedChannels() {
     net1_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
     net2_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
     recv1_.reset(new SctpFakeDataReceiver());
     recv2_.reset(new SctpFakeDataReceiver());
     chan1_ready_to_send_count_ = 0;
     chan2_ready_to_send_count_ = 0;
     chan1_.reset(CreateChannel(net1_.get(), recv1_.get()));
     chan1_->set_debug_name_for_testing("chan1/connector");
     chan1_->SignalReadyToSend.connect(
         this, &SctpDataMediaChannelTest::OnChan1ReadyToSend);
     chan2_.reset(CreateChannel(net2_.get(), recv2_.get()));
     chan2_->set_debug_name_for_testing("chan2/listener");
     chan2_->SignalReadyToSend.connect(
         this, &SctpDataMediaChannelTest::OnChan2ReadyToSend);
     // Setup two connected channels ready to send and receive.
     net1_->SetDestination(chan2_.get());
     net2_->SetDestination(chan1_.get());

     LOG(LS_VERBOSE) << "Channel setup ----------------------------- ";
     AddStream(1);
     AddStream(2);

     LOG(LS_VERBOSE) << "Connect the channels -----------------------------";
     // chan1 wants to setup a data connection.
     chan1_->SetReceive(true);
     // chan1 will have sent chan2 a request to setup a data connection. After
     // chan2 accepts the offer, chan2 connects to chan1 with the following.
     chan2_->SetReceive(true);
     chan2_->SetSend(true);
     // Makes sure that network packets are delivered and simulates a
     // deterministic and realistic small timing delay between the SetSend calls.
     ProcessMessagesUntilIdle();

     // chan1 and chan2 are now connected so chan1 enables sending to complete
     // the creation of the connection.
     chan1_->SetSend(true);
   }

   virtual void TearDown() {
     channel1()->SetSend(false);
     channel2()->SetSend(false);

     // Process messages until idle to prevent a sent packet from being dropped
     // and causing memory leaks (not being deleted by the receiver).
     ProcessMessagesUntilIdle();
   }

   bool AddStream(int ssrc) {
     bool ret = true;
     StreamParams p(StreamParams::CreateLegacy(ssrc));
     ret = ret && chan1_->AddSendStream(p);
     ret = ret && chan1_->AddRecvStream(p);
     ret = ret && chan2_->AddSendStream(p);
     ret = ret && chan2_->AddRecvStream(p);
     return ret;
   }

   SctpDataMediaChannel* CreateChannel(SctpFakeNetworkInterface* net,
                                       SctpFakeDataReceiver* recv) {
     SctpDataMediaChannel* channel =
         static_cast<SctpDataMediaChannel*>(engine_->CreateChannel(DCT_SCTP));
     channel->SetInterface(net);
     // When data is received, pass it to the SctpFakeDataReceiver.
     channel->SignalDataReceived.connect(
         recv, &SctpFakeDataReceiver::OnDataReceived);
     return channel;
   }

   bool SendData(SctpDataMediaChannel* chan,
                 uint32_t ssrc,
                 const std::string& msg,
                 SendDataResult* result) {
     SendDataParams params;
     params.ssrc = ssrc;

     return chan->SendData(params, rtc::CopyOnWriteBuffer(
         &msg[0], msg.length()), result);
   }

   bool ReceivedData(const SctpFakeDataReceiver* recv,
                     uint32_t ssrc,
                     const std::string& msg) {
     return (recv->received() &&
             recv->last_params().ssrc == ssrc &&
             recv->last_data() == msg);
   }

   bool ProcessMessagesUntilIdle() {
     rtc::Thread* thread = rtc::Thread::Current();
     while (!thread->empty()) {
       rtc::Message msg;
       if (thread->Get(&msg, rtc::Thread::kForever)) {
         thread->Dispatch(&msg);
       }
     }
     return !thread->IsQuitting();
   }

   SctpDataMediaChannel* channel1() { return chan1_.get(); }
   SctpDataMediaChannel* channel2() { return chan2_.get(); }
   SctpFakeDataReceiver* receiver1() { return recv1_.get(); }
   SctpFakeDataReceiver* receiver2() { return recv2_.get(); }

   int channel1_ready_to_send_count() { return chan1_ready_to_send_count_; }
   int channel2_ready_to_send_count() { return chan2_ready_to_send_count_; }
  private:
   std::unique_ptr<SctpDataEngine> engine_;
   std::unique_ptr<SctpFakeNetworkInterface> net1_;
   std::unique_ptr<SctpFakeNetworkInterface> net2_;
   std::unique_ptr<SctpFakeDataReceiver> recv1_;
   std::unique_ptr<SctpFakeDataReceiver> recv2_;
   std::unique_ptr<SctpDataMediaChannel> chan1_;
   std::unique_ptr<SctpDataMediaChannel> chan2_;

   int chan1_ready_to_send_count_;
   int chan2_ready_to_send_count_;

   void OnChan1ReadyToSend(bool send) {
     if (send)
       ++chan1_ready_to_send_count_;
   }
   void OnChan2ReadyToSend(bool send) {
     if (send)
       ++chan2_ready_to_send_count_;
   }
 };

 // Verifies that SignalReadyToSend is fired.
 TEST_F(SctpDataMediaChannelTest, SignalReadyToSend) {
   SetupConnectedChannels();

   SignalReadyToSendObserver signal_observer_1;
   SignalReadyToSendObserver signal_observer_2;

   channel1()->SignalReadyToSend.connect(&signal_observer_1,
                                         &SignalReadyToSendObserver::OnSignaled);
   channel2()->SignalReadyToSend.connect(&signal_observer_2,
                                         &SignalReadyToSendObserver::OnSignaled);

   SendDataResult result;
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
   ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

   EXPECT_TRUE_WAIT(signal_observer_1.IsSignaled(true), 1000);
   EXPECT_TRUE_WAIT(signal_observer_2.IsSignaled(true), 1000);
 }

 TEST_F(SctpDataMediaChannelTest, SendData) {
   SetupConnectedChannels();

   SendDataResult result;
   LOG(LS_VERBOSE) << "chan1 sending: 'hello?' -----------------------------";
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
   LOG(LS_VERBOSE) << "recv2.received=" << receiver2()->received()
                   << ", recv2.last_params.ssrc="
                   << receiver2()->last_params().ssrc
                   << ", recv2.last_params.timestamp="
                   << receiver2()->last_params().ssrc
                   << ", recv2.last_params.seq_num="
                   << receiver2()->last_params().seq_num
                   << ", recv2.last_data=" << receiver2()->last_data();

   LOG(LS_VERBOSE) << "chan2 sending: 'hi chan1' -----------------------------";
   ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);
   LOG(LS_VERBOSE) << "recv1.received=" << receiver1()->received()
                   << ", recv1.last_params.ssrc="
                   << receiver1()->last_params().ssrc
                   << ", recv1.last_params.timestamp="
                   << receiver1()->last_params().ssrc
                   << ", recv1.last_params.seq_num="
                   << receiver1()->last_params().seq_num
                   << ", recv1.last_data=" << receiver1()->last_data();
 }

 // Sends a lot of large messages at once and verifies SDR_BLOCK is returned.
 TEST_F(SctpDataMediaChannelTest, SendDataBlocked) {
   SetupConnectedChannels();

   SendDataResult result;
   SendDataParams params;
   params.ssrc = 1;

   std::vector<char> buffer(1024 * 64, 0);

   for (size_t i = 0; i < 100; ++i) {
     channel1()->SendData(
         params, rtc::CopyOnWriteBuffer(&buffer[0], buffer.size()), &result);
     if (result == SDR_BLOCK)
       break;
   }

   EXPECT_EQ(SDR_BLOCK, result);
 }

 TEST_F(SctpDataMediaChannelTest, ClosesRemoteStream) {
   SetupConnectedChannels();
   SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
   chan_1_sig_receiver.BindSelf(channel1());
   chan_2_sig_receiver.BindSelf(channel2());

   SendDataResult result;
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
   ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

   // Close channel 1.  Channel 2 should notify us.
   channel1()->RemoveSendStream(1);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
 }

 TEST_F(SctpDataMediaChannelTest, ClosesTwoRemoteStreams) {
   SetupConnectedChannels();
   AddStream(3);
   SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
   chan_1_sig_receiver.BindSelf(channel1());
   chan_2_sig_receiver.BindSelf(channel2());

   SendDataResult result;
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
   ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

   // Close two streams on one side.
   channel2()->RemoveSendStream(2);
   channel2()->RemoveSendStream(3);
   EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(2), 1000);
   EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(3), 1000);
 }

 TEST_F(SctpDataMediaChannelTest, ClosesStreamsOnBothSides) {
   SetupConnectedChannels();
   AddStream(3);
   AddStream(4);
   SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
   chan_1_sig_receiver.BindSelf(channel1());
   chan_2_sig_receiver.BindSelf(channel2());

   SendDataResult result;
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
   ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

   // Close one stream on channel1(), while closing three streams on
   // channel2().  They will conflict (only one side can close anything at a
   // time, apparently).  Test the resolution of the conflict.
   channel1()->RemoveSendStream(1);

   channel2()->RemoveSendStream(2);
   channel2()->RemoveSendStream(3);
   channel2()->RemoveSendStream(4);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
   EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(2), 1000);
   EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(3), 1000);
   EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(4), 1000);
 }

 TEST_F(SctpDataMediaChannelTest, EngineSignalsRightChannel) {
   SetupConnectedChannels();
   EXPECT_TRUE_WAIT(channel1()->socket() != NULL, 1000);
   struct socket *sock = const_cast<struct socket*>(channel1()->socket());
   int prior_count = channel1_ready_to_send_count();
   SctpDataMediaChannel::SendThresholdCallback(sock, 0);
   EXPECT_GT(channel1_ready_to_send_count(), prior_count);
 }

 TEST_F(SctpDataMediaChannelTest, RefusesHighNumberedChannels) {
   SetupConnectedChannels();
   EXPECT_TRUE(AddStream(kMaxSctpSid));
   EXPECT_FALSE(AddStream(kMaxSctpSid + 1));
 }

 // Flaky, see webrtc:4453.
 TEST_F(SctpDataMediaChannelTest, DISABLED_ReusesAStream) {
   // Shut down channel 1, then open it up again for reuse.
   SetupConnectedChannels();
   SendDataResult result;
   SignalChannelClosedObserver chan_2_sig_receiver;
   chan_2_sig_receiver.BindSelf(channel2());

   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);

   channel1()->RemoveSendStream(1);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
   // Channel 1 is gone now.

   // Create a new channel 1.
   AddStream(1);
   ASSERT_TRUE(SendData(channel1(), 1, "hi?", &result));
   EXPECT_EQ(SDR_SUCCESS, result);
   EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), 1000);
   channel1()->RemoveSendStream(1);
   EXPECT_TRUE_WAIT(chan_2_sig_receiver.StreamCloseCount(1) == 2, 1000);
 }

 }  // namespace cricket
	/*
	* Copyright (c) 2013 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.
	*/

	#include <errno.h>
	#include <stdarg.h>
	#include <stdio.h>

	#include <memory>
	#include <string>
	#include <vector>

	#include "webrtc/base/bind.h"
	#include "webrtc/base/copyonwritebuffer.h"
	#include "webrtc/base/criticalsection.h"
	#include "webrtc/base/gunit.h"
	#include "webrtc/base/helpers.h"
	#include "webrtc/base/messagehandler.h"
	#include "webrtc/base/messagequeue.h"
	#include "webrtc/base/ssladapter.h"
	#include "webrtc/base/thread.h"
	#include "webrtc/media/base/mediachannel.h"
	#include "webrtc/media/base/mediaconstants.h"
	#include "webrtc/media/sctp/sctpdataengine.h"

	namespace cricket {
	enum {
	MSG_PACKET = 1,
	};

	// Fake NetworkInterface that sends/receives sctp packets. The one in
	// webrtc/media/base/fakenetworkinterface.h only works with rtp/rtcp.
	class SctpFakeNetworkInterface : public MediaChannel::NetworkInterface,
	public rtc::MessageHandler {
	public:
	explicit SctpFakeNetworkInterface(rtc::Thread* thread)
	: thread_(thread),
	dest_(NULL) {
	}

	void SetDestination(DataMediaChannel* dest) { dest_ = dest; }

	protected:
	// Called to send raw packet down the wire (e.g. SCTP an packet).
	virtual bool SendPacket(rtc::CopyOnWriteBuffer* packet,
	const rtc::PacketOptions& options) {
	LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket";

	rtc::CopyOnWriteBuffer* buffer = new rtc::CopyOnWriteBuffer(*packet);
	thread_->Post(RTC_FROM_HERE, this, MSG_PACKET,
	rtc::WrapMessageData(buffer));
	LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::SendPacket, Posted message.";
	return true;
	}

	// Called when a raw packet has been recieved. This passes the data to the
	// code that will interpret the packet. e.g. to get the content payload from
	// an SCTP packet.
	virtual void OnMessage(rtc::Message* msg) {
	LOG(LS_VERBOSE) << "SctpFakeNetworkInterface::OnMessage";
	std::unique_ptr<rtc::CopyOnWriteBuffer> buffer(
	static_cast<rtc::TypedMessageData<rtc::CopyOnWriteBuffer>>(
	msg->pdata)->data());
	if (dest_) {
	dest_->OnPacketReceived(buffer.get(), rtc::PacketTime());
	}
	delete msg->pdata;
	}

	// Unsupported functions required to exist by NetworkInterface.
	// TODO(ldixon): Refactor parent NetworkInterface class so these are not
	// required. They are RTC specific and should be in an appropriate subclass.
	virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
	const rtc::PacketOptions& options) {
	LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SendRtcp.";
	return false;
	}
	virtual int SetOption(SocketType type, rtc::Socket::Option opt,
	int option) {
	LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
	return 0;
	}
	virtual void SetDefaultDSCPCode(rtc::DiffServCodePoint dscp) {
	LOG(LS_WARNING) << "Unsupported: SctpFakeNetworkInterface::SetOption.";
	}

	private:
	// Not owned by this class.
	rtc::Thread* thread_;
	DataMediaChannel* dest_;
	};

	// This is essentially a buffer to hold recieved data. It stores only the last
	// received data. Calling OnDataReceived twice overwrites old data with the
	// newer one.
	// TODO(ldixon): Implement constraints, and allow new data to be added to old
	// instead of replacing it.
	class SctpFakeDataReceiver : public sigslot::has_slots<> {
	public:
	SctpFakeDataReceiver() : received_(false) {}

	void Clear() {
	received_ = false;
	last_data_ = "";
	last_params_ = ReceiveDataParams();
	}

	virtual void OnDataReceived(const ReceiveDataParams& params,
	const char* data,
	size_t length) {
	received_ = true;
	last_data_ = std::string(data, length);
	last_params_ = params;
	}

	bool received() const { return received_; }
	std::string last_data() const { return last_data_; }
	ReceiveDataParams last_params() const { return last_params_; }

	private:
	bool received_;
	std::string last_data_;
	ReceiveDataParams last_params_;
	};

	class SignalReadyToSendObserver : public sigslot::has_slots<> {
	public:
	SignalReadyToSendObserver() : signaled_(false), writable_(false) {}

	void OnSignaled(bool writable) {
	signaled_ = true;
	writable_ = writable;
	}

	bool IsSignaled(bool writable) {
	return signaled_ && (writable_ == writable);
	}

	private:
	bool signaled_;
	bool writable_;
	};

	class SignalChannelClosedObserver : public sigslot::has_slots<> {
	public:
	SignalChannelClosedObserver() {}
	void BindSelf(SctpDataMediaChannel* channel) {
	channel->SignalStreamClosedRemotely.connect(
	this, &SignalChannelClosedObserver::OnStreamClosed);
	}
	void OnStreamClosed(uint32_t stream) { streams_.push_back(stream); }

	int StreamCloseCount(uint32_t stream) {
	return std::count(streams_.begin(), streams_.end(), stream);
	}

	bool WasStreamClosed(uint32_t stream) {
	return std::find(streams_.begin(), streams_.end(), stream)
	!= streams_.end();
	}

	private:
	std::vector<uint32_t> streams_;
	};

	class SignalChannelClosedReopener : public sigslot::has_slots<> {
	public:
	SignalChannelClosedReopener(SctpDataMediaChannel* channel,
	SctpDataMediaChannel* peer)
	: channel_(channel), peer_(peer) {}

	void OnStreamClosed(int stream) {
	StreamParams p(StreamParams::CreateLegacy(stream));
	channel_->AddSendStream(p);
	channel_->AddRecvStream(p);
	peer_->AddSendStream(p);
	peer_->AddRecvStream(p);
	streams_.push_back(stream);
	}

	int StreamCloseCount(int stream) {
	return std::count(streams_.begin(), streams_.end(), stream);
	}

	private:
	SctpDataMediaChannel* channel_;
	SctpDataMediaChannel* peer_;
	std::vector<int> streams_;
	};

	// SCTP Data Engine testing framework.
	class SctpDataMediaChannelTest : public testing::Test,
	public sigslot::has_slots<> {
	protected:
	// usrsctp uses the NSS random number generator on non-Android platforms,
	// so we need to initialize SSL.
	static void SetUpTestCase() {
	}

	virtual void SetUp() { engine_.reset(new SctpDataEngine()); }

	void SetupConnectedChannels() {
	net1_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
	net2_.reset(new SctpFakeNetworkInterface(rtc::Thread::Current()));
	recv1_.reset(new SctpFakeDataReceiver());
	recv2_.reset(new SctpFakeDataReceiver());
	chan1_ready_to_send_count_ = 0;
	chan2_ready_to_send_count_ = 0;
	chan1_.reset(CreateChannel(net1_.get(), recv1_.get()));
	chan1_->set_debug_name_for_testing("chan1/connector");
	chan1_->SignalReadyToSend.connect(
	this, &SctpDataMediaChannelTest::OnChan1ReadyToSend);
	chan2_.reset(CreateChannel(net2_.get(), recv2_.get()));
	chan2_->set_debug_name_for_testing("chan2/listener");
	chan2_->SignalReadyToSend.connect(
	this, &SctpDataMediaChannelTest::OnChan2ReadyToSend);
	// Setup two connected channels ready to send and receive.
	net1_->SetDestination(chan2_.get());
	net2_->SetDestination(chan1_.get());

	LOG(LS_VERBOSE) << "Channel setup ----------------------------- ";
	AddStream(1);
	AddStream(2);

	LOG(LS_VERBOSE) << "Connect the channels -----------------------------";
	// chan1 wants to setup a data connection.
	chan1_->SetReceive(true);
	// chan1 will have sent chan2 a request to setup a data connection. After
	// chan2 accepts the offer, chan2 connects to chan1 with the following.
	chan2_->SetReceive(true);
	chan2_->SetSend(true);
	// Makes sure that network packets are delivered and simulates a
	// deterministic and realistic small timing delay between the SetSend calls.
	ProcessMessagesUntilIdle();

	// chan1 and chan2 are now connected so chan1 enables sending to complete
	// the creation of the connection.
	chan1_->SetSend(true);
	}

	virtual void TearDown() {
	channel1()->SetSend(false);
	channel2()->SetSend(false);

	// Process messages until idle to prevent a sent packet from being dropped
	// and causing memory leaks (not being deleted by the receiver).
	ProcessMessagesUntilIdle();
	}

	bool AddStream(int ssrc) {
	bool ret = true;
	StreamParams p(StreamParams::CreateLegacy(ssrc));
	ret = ret && chan1_->AddSendStream(p);
	ret = ret && chan1_->AddRecvStream(p);
	ret = ret && chan2_->AddSendStream(p);
	ret = ret && chan2_->AddRecvStream(p);
	return ret;
	}

	SctpDataMediaChannel* CreateChannel(SctpFakeNetworkInterface* net,
	SctpFakeDataReceiver* recv) {
	SctpDataMediaChannel* channel =
	static_cast<SctpDataMediaChannel*>(engine_->CreateChannel(DCT_SCTP));
	channel->SetInterface(net);
	// When data is received, pass it to the SctpFakeDataReceiver.
	channel->SignalDataReceived.connect(
	recv, &SctpFakeDataReceiver::OnDataReceived);
	return channel;
	}

	bool SendData(SctpDataMediaChannel* chan,
	uint32_t ssrc,
	const std::string& msg,
	SendDataResult* result) {
	SendDataParams params;
	params.ssrc = ssrc;

	return chan->SendData(params, rtc::CopyOnWriteBuffer(
	&msg[0], msg.length()), result);
	}

	bool ReceivedData(const SctpFakeDataReceiver* recv,
	uint32_t ssrc,
	const std::string& msg) {
	return (recv->received() &&
	recv->last_params().ssrc == ssrc &&
	recv->last_data() == msg);
	}

	bool ProcessMessagesUntilIdle() {
	rtc::Thread* thread = rtc::Thread::Current();
	while (!thread->empty()) {
	rtc::Message msg;
	if (thread->Get(&msg, rtc::Thread::kForever)) {
	thread->Dispatch(&msg);
	}
	}
	return !thread->IsQuitting();
	}

	SctpDataMediaChannel* channel1() { return chan1_.get(); }
	SctpDataMediaChannel* channel2() { return chan2_.get(); }
	SctpFakeDataReceiver* receiver1() { return recv1_.get(); }
	SctpFakeDataReceiver* receiver2() { return recv2_.get(); }

	int channel1_ready_to_send_count() { return chan1_ready_to_send_count_; }
	int channel2_ready_to_send_count() { return chan2_ready_to_send_count_; }
	private:
	std::unique_ptr<SctpDataEngine> engine_;
	std::unique_ptr<SctpFakeNetworkInterface> net1_;
	std::unique_ptr<SctpFakeNetworkInterface> net2_;
	std::unique_ptr<SctpFakeDataReceiver> recv1_;
	std::unique_ptr<SctpFakeDataReceiver> recv2_;
	std::unique_ptr<SctpDataMediaChannel> chan1_;
	std::unique_ptr<SctpDataMediaChannel> chan2_;

	int chan1_ready_to_send_count_;
	int chan2_ready_to_send_count_;

	void OnChan1ReadyToSend(bool send) {
	if (send)
	++chan1_ready_to_send_count_;
	}
	void OnChan2ReadyToSend(bool send) {
	if (send)
	++chan2_ready_to_send_count_;
	}
	};

	// Verifies that SignalReadyToSend is fired.
	TEST_F(SctpDataMediaChannelTest, SignalReadyToSend) {
	SetupConnectedChannels();

	SignalReadyToSendObserver signal_observer_1;
	SignalReadyToSendObserver signal_observer_2;

	channel1()->SignalReadyToSend.connect(&signal_observer_1,
	&SignalReadyToSendObserver::OnSignaled);
	channel2()->SignalReadyToSend.connect(&signal_observer_2,
	&SignalReadyToSendObserver::OnSignaled);

	SendDataResult result;
	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
	ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

	EXPECT_TRUE_WAIT(signal_observer_1.IsSignaled(true), 1000);
	EXPECT_TRUE_WAIT(signal_observer_2.IsSignaled(true), 1000);
	}

	TEST_F(SctpDataMediaChannelTest, SendData) {
	SetupConnectedChannels();

	SendDataResult result;
	LOG(LS_VERBOSE) << "chan1 sending: 'hello?' -----------------------------";
	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
	LOG(LS_VERBOSE) << "recv2.received=" << receiver2()->received()
	<< ", recv2.last_params.ssrc="
	<< receiver2()->last_params().ssrc
	<< ", recv2.last_params.timestamp="
	<< receiver2()->last_params().ssrc
	<< ", recv2.last_params.seq_num="
	<< receiver2()->last_params().seq_num
	<< ", recv2.last_data=" << receiver2()->last_data();

	LOG(LS_VERBOSE) << "chan2 sending: 'hi chan1' -----------------------------";
	ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);
	LOG(LS_VERBOSE) << "recv1.received=" << receiver1()->received()
	<< ", recv1.last_params.ssrc="
	<< receiver1()->last_params().ssrc
	<< ", recv1.last_params.timestamp="
	<< receiver1()->last_params().ssrc
	<< ", recv1.last_params.seq_num="
	<< receiver1()->last_params().seq_num
	<< ", recv1.last_data=" << receiver1()->last_data();
	}

	// Sends a lot of large messages at once and verifies SDR_BLOCK is returned.
	TEST_F(SctpDataMediaChannelTest, SendDataBlocked) {
	SetupConnectedChannels();

	SendDataResult result;
	SendDataParams params;
	params.ssrc = 1;

	std::vector<char> buffer(1024 * 64, 0);

	for (size_t i = 0; i < 100; ++i) {
	channel1()->SendData(
	params, rtc::CopyOnWriteBuffer(&buffer[0], buffer.size()), &result);
	if (result == SDR_BLOCK)
	break;
	}

	EXPECT_EQ(SDR_BLOCK, result);
	}

	TEST_F(SctpDataMediaChannelTest, ClosesRemoteStream) {
	SetupConnectedChannels();
	SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
	chan_1_sig_receiver.BindSelf(channel1());
	chan_2_sig_receiver.BindSelf(channel2());

	SendDataResult result;
	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
	ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

	// Close channel 1. Channel 2 should notify us.
	channel1()->RemoveSendStream(1);
	EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
	}

	TEST_F(SctpDataMediaChannelTest, ClosesTwoRemoteStreams) {
	SetupConnectedChannels();
	AddStream(3);
	SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
	chan_1_sig_receiver.BindSelf(channel1());
	chan_2_sig_receiver.BindSelf(channel2());

	SendDataResult result;
	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
	ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

	// Close two streams on one side.
	channel2()->RemoveSendStream(2);
	channel2()->RemoveSendStream(3);
	EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(2), 1000);
	EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(3), 1000);
	}

	TEST_F(SctpDataMediaChannelTest, ClosesStreamsOnBothSides) {
	SetupConnectedChannels();
	AddStream(3);
	AddStream(4);
	SignalChannelClosedObserver chan_1_sig_receiver, chan_2_sig_receiver;
	chan_1_sig_receiver.BindSelf(channel1());
	chan_2_sig_receiver.BindSelf(channel2());

	SendDataResult result;
	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);
	ASSERT_TRUE(SendData(channel2(), 2, "hi chan1", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi chan1"), 1000);

	// Close one stream on channel1(), while closing three streams on
	// channel2(). They will conflict (only one side can close anything at a
	// time, apparently). Test the resolution of the conflict.
	channel1()->RemoveSendStream(1);

	channel2()->RemoveSendStream(2);
	channel2()->RemoveSendStream(3);
	channel2()->RemoveSendStream(4);
	EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
	EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(2), 1000);
	EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(3), 1000);
	EXPECT_TRUE_WAIT(chan_1_sig_receiver.WasStreamClosed(4), 1000);
	}

	TEST_F(SctpDataMediaChannelTest, EngineSignalsRightChannel) {
	SetupConnectedChannels();
	EXPECT_TRUE_WAIT(channel1()->socket() != NULL, 1000);
	struct socket sock = const_cast<struct socket>(channel1()->socket());
	int prior_count = channel1_ready_to_send_count();
	SctpDataMediaChannel::SendThresholdCallback(sock, 0);
	EXPECT_GT(channel1_ready_to_send_count(), prior_count);
	}

	TEST_F(SctpDataMediaChannelTest, RefusesHighNumberedChannels) {
	SetupConnectedChannels();
	EXPECT_TRUE(AddStream(kMaxSctpSid));
	EXPECT_FALSE(AddStream(kMaxSctpSid + 1));
	}

	// Flaky, see webrtc:4453.
	TEST_F(SctpDataMediaChannelTest, DISABLED_ReusesAStream) {
	// Shut down channel 1, then open it up again for reuse.
	SetupConnectedChannels();
	SendDataResult result;
	SignalChannelClosedObserver chan_2_sig_receiver;
	chan_2_sig_receiver.BindSelf(channel2());

	ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), 1000);

	channel1()->RemoveSendStream(1);
	EXPECT_TRUE_WAIT(chan_2_sig_receiver.WasStreamClosed(1), 1000);
	// Channel 1 is gone now.

	// Create a new channel 1.
	AddStream(1);
	ASSERT_TRUE(SendData(channel1(), 1, "hi?", &result));
	EXPECT_EQ(SDR_SUCCESS, result);
	EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), 1000);
	channel1()->RemoveSendStream(1);
	EXPECT_TRUE_WAIT(chan_2_sig_receiver.StreamCloseCount(1) == 2, 1000);
	}

	} // namespace cricket