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"),
+  });
+
+  // Default values.
+  EXPECT_EQ(0U, webrtc_data_channel_->messages_sent());
+  EXPECT_EQ(0U, webrtc_data_channel_->bytes_sent());
+
+  // Send three buffers while not blocked.
+  provider_->set_send_blocked(false);
+  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_WAIT(0U, webrtc_data_channel_->buffered_amount(), 1000);

[Taylor Brandstetter, 2016/10/12 19:43:58]

I'd use kDefaultTimeout. Any time a test doesn't actually care about the time -
just that something happens eventually in the future - it's good to use a long
timeout so the test doesn't fail if running on a slow bot.

[hbos, 2016/10/12 20:04:48]

Done.

+  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;
+
+  // Default values.
+  EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
+  EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
+
+  // Receive three buffers while blocked.

[Taylor Brandstetter, 2016/10/12 19:43:58]

I'd clarify that this is "while the data channel isn't open", rather than "while
blocked".

[hbos, 2016/10/12 20:04:48]

Done.

+  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);
 }