DataChannel[Interface]::[message/bytes]_[sent/received]() added.

webrtc/api/datachannel_unittest.cc

Index: webrtc/api/datachannel_unittest.cc
diff --git a/webrtc/api/datachannel_unittest.cc b/webrtc/api/datachannel_unittest.cc
index e2a8eed638cbb2467b88aa9d10811c7bf6a21836..2dd64b461b7e483dedbdcb0fc85af9f3544afdec 100644
--- a/webrtc/api/datachannel_unittest.cc
+++ b/webrtc/api/datachannel_unittest.cc
@@ -195,6 +195,49 @@ TEST_F(SctpDataChannelTest, BlockedWhenSendQueuedDataNoCrash) {
   EXPECT_EQ(2U, observer_->on_buffered_amount_change_count());
 }
 
+// Tests that DataChannel::messages_sent() and DataChannel::bytes_sent() are
+// correct, sending data both while unblocked and while blocked.
+TEST_F(SctpDataChannelTest, VerifyMessagesAndBytesSent) {
+  AddObserver();
+  SetChannelReady();
+  std::vector<webrtc::DataBuffer> buffers({
+    webrtc::DataBuffer("message 1"),
+    webrtc::DataBuffer("msg 2"),
+    webrtc::DataBuffer("message three"),
+    webrtc::DataBuffer("quadra message"),
+    webrtc::DataBuffer("fifthmsg"),
+    webrtc::DataBuffer("message of the beast"),
+  });
+
+  // Send three buffers while not blocked.
+  provider_->set_send_blocked(false);

[hta-webrtc, 2016/10/12 17:25:28]

check that messages_sent and bytes_sent are zero at start too.

[hbos, 2016/10/12 18:25:07]

Done. Did the same for messages_received and bytes_received in the other test.

+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[0]));
+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[1]));
+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[2]));
+  size_t bytes_sent = buffers[0].size() + buffers[1].size() + buffers[2].size();
+  EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());

[hta-webrtc, 2016/10/12 17:25:28]

Is this 100% reliable, or do we need it to be EXPECT_EQ_WAIT?

(i'm fine with it being EXPECT_EQ if you have looked at the implementation and
concluded that Send() will always empty the buffer when it's wired like it is.
Just afraid of flaky tests.)

[hbos, 2016/10/12 18:25:07]

Yes, but there are interfaces and stuff involved so I changed it to
EXPECT_EQ_WAIT to avoid assumptions.

+  EXPECT_EQ(3U, webrtc_data_channel_->messages_sent());
+  EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
+
+  // Send three buffers while blocked, queuing the buffers.
+  provider_->set_send_blocked(true);
+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[3]));
+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[4]));
+  EXPECT_TRUE(webrtc_data_channel_->Send(buffers[5]));
+  size_t bytes_queued =
+      buffers[3].size() + buffers[4].size() + buffers[5].size();
+  EXPECT_EQ(bytes_queued, webrtc_data_channel_->buffered_amount());
+  EXPECT_EQ(3U, webrtc_data_channel_->messages_sent());
+  EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
+
+  // Unblock and make sure everything was sent.
+  provider_->set_send_blocked(false);
+  EXPECT_EQ_WAIT(0U, webrtc_data_channel_->buffered_amount(), 1000);
+  bytes_sent += bytes_queued;
+  EXPECT_EQ(6U, webrtc_data_channel_->messages_sent());
+  EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
+}
+
 // Tests that the queued control message is sent when channel is ready.
 TEST_F(SctpDataChannelTest, OpenMessageSent) {
   // Initially the id is unassigned.
@@ -374,6 +417,49 @@ TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
   EXPECT_EQ(0U, provider_->last_send_data_params().ssrc);
 }
 
+// Tests that DataChannel::messages_received() and DataChannel::bytes_received()
+// are correct, receiving data both while blocked and while unblocked.
+TEST_F(SctpDataChannelTest, VerifyMessagesAndBytesReceived) {
+  AddObserver();
+  std::vector<webrtc::DataBuffer> buffers({
+    webrtc::DataBuffer("message 1"),
+    webrtc::DataBuffer("msg 2"),
+    webrtc::DataBuffer("message three"),
+    webrtc::DataBuffer("quadra message"),
+    webrtc::DataBuffer("fifthmsg"),
+    webrtc::DataBuffer("message of the beast"),
+  });
+
+  webrtc_data_channel_->SetSctpSid(1);
+  cricket::ReceiveDataParams params;
+  params.ssrc = 1;
+
+  // Receive three buffers while blocked.
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[0].data);
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[1].data);
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[2].data);
+  EXPECT_EQ(0U, observer_->messages_received());
+  EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
+  EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
+
+  // Unblock and make sure everything was received.
+  SetChannelReady();
+  size_t bytes_received =
+      buffers[0].size() + buffers[1].size() + buffers[2].size();
+  EXPECT_EQ(3U, observer_->messages_received());
+  EXPECT_EQ(3U, webrtc_data_channel_->messages_received());
+  EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
+
+  // Receive three buffers while unblocked.
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[3].data);
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[4].data);
+  webrtc_data_channel_->OnDataReceived(nullptr, params, buffers[5].data);
+  bytes_received += buffers[3].size() + buffers[4].size() + buffers[5].size();
+  EXPECT_EQ(6U, observer_->messages_received());
+  EXPECT_EQ(6U, webrtc_data_channel_->messages_received());
+  EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
+}
+
 // Tests that OPEN_ACK message is sent if the datachannel is created from an
 // OPEN message.
 TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {