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

webrtc/api/datachannel_unittest.cc

 /*
  *  Copyright 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.
  */
 
@@ skipping 177 matching lines @@
   EXPECT_EQ(buffer.size(), webrtc_data_channel_->buffered_amount());
   EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());
 
   // Unblock the channel to send queued data again, there should be no crash.
   provider_->set_send_blocked(false);
   SetChannelReady();
   EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
   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.
   EXPECT_EQ(-1, webrtc_data_channel_->id());
 
   SetChannelReady();
   EXPECT_GE(webrtc_data_channel_->id(), 0);
   EXPECT_EQ(cricket::DMT_CONTROL, provider_->last_send_data_params().type);
   EXPECT_EQ(provider_->last_send_data_params().ssrc,
             static_cast<uint32_t>(webrtc_data_channel_->id()));
@@ skipping 159 matching lines @@
   config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;
 
   SetChannelReady();
   rtc::scoped_refptr<DataChannel> dc =
       DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "test1", config);
 
   EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
   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) {
   webrtc::InternalDataChannelInit config;
   config.id = 1;
   config.negotiated = true;
   config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;
 
   SetChannelReady();
   rtc::scoped_refptr<DataChannel> dc =
@@ skipping 195 matching lines @@
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id, allocated_id);
 
   // Verifies that used higher ids are not reused.
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
   EXPECT_EQ(odd_id + 6, allocated_id);
 
   EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
   EXPECT_EQ(even_id + 6, allocated_id);
 }