Added send-thresholding and fixed text packet dumping.

talk/media/sctp/sctpdataengine_unittest.cc

 /*
  * libjingle
  * Copyright 2013 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 222 matching lines @@
 
   virtual void SetUp() {
     engine_.reset(new cricket::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("chan1/connector");
+    chan1_->SignalReadyToSend.connect(
+        this, &SctpDataMediaChannelTest::OnChan1ReadyToSend);
     chan2_.reset(CreateChannel(net2_.get(), recv2_.get()));
     chan2_->set_debug_name("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.
@@ skipping 66 matching lines @@
       }
     }
     return !thread->IsQuitting();
   }
 
   cricket::SctpDataMediaChannel* channel1() { return chan1_.get(); }
   cricket::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:
   rtc::scoped_ptr<cricket::SctpDataEngine> engine_;
   rtc::scoped_ptr<SctpFakeNetworkInterface> net1_;
   rtc::scoped_ptr<SctpFakeNetworkInterface> net2_;
   rtc::scoped_ptr<SctpFakeDataReceiver> recv1_;
   rtc::scoped_ptr<SctpFakeDataReceiver> recv2_;
   rtc::scoped_ptr<cricket::SctpDataMediaChannel> chan1_;
   rtc::scoped_ptr<cricket::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_++; }

[tommi, 2015/08/27 11:38:02]

nit: use postfix ++ (style guide thing)

it's also a good thing to not have if() and the body of the if, on the same
line. It makes it harder to set breakpoints.

[lally1, 2015/08/27 17:56:09]

Done.

+  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,
@@ skipping 128 matching lines @@
 
   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();
+  cricket::SctpDataEngine::SendThresholdCallback(sock, 0);
+  EXPECT_GT(channel1_ready_to_send_count(), prior_count);
+}
+
 // Flaky on Linux and Windows. See webrtc:4453.
 #if defined(WEBRTC_WIN) || defined(WEBRTC_LINUX)
 #define MAYBE_ReusesAStream DISABLED_ReusesAStream
 #else
 #define MAYBE_ReusesAStream ReusesAStream
 #endif
 TEST_F(SctpDataMediaChannelTest, MAYBE_ReusesAStream) {
   // Shut down channel 1, then open it up again for reuse.
   SetupConnectedChannels();
   cricket::SendDataResult result;
   SignalChannelClosedObserver chan_2_sig_receiver;
   chan_2_sig_receiver.BindSelf(channel2());
 
   ASSERT_TRUE(SendData(channel1(), 1, "hello?", &result));
   EXPECT_EQ(cricket::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(cricket::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);
 }