RTCDataChannelStats added.

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 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 310 matching lines @@
   RTCStatsCollectorTest()
     : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()),
       collector_(RTCStatsCollector::Create(
           &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) {
   }
 
   rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
     rtc::scoped_refptr<StatsCallback> callback = StatsCallback::Create();
     collector_->GetStatsReport(callback);
     EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
+    int64_t after = rtc::TimeUTCMicros();
+    for (const RTCStats& stats : *callback->report()) {
+      EXPECT_LE(stats.timestamp_us(), after);
+    }
     return callback->report();
   }
 
   const RTCIceCandidateStats* ExpectReportContainsCandidate(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const cricket::Candidate& candidate,
       bool is_local) {
     const RTCStats* stats = report->Get("RTCIceCandidate_" + candidate.id());
     EXPECT_TRUE(stats);
     const RTCIceCandidateStats* candidate_stats;
     if (is_local)
         candidate_stats = &stats->cast_to<RTCLocalIceCandidateStats>();
     else
         candidate_stats = &stats->cast_to<RTCRemoteIceCandidateStats>();
     EXPECT_EQ(*candidate_stats->ip, candidate.address().ipaddr().ToString());
     EXPECT_EQ(*candidate_stats->port,
               static_cast<int32_t>(candidate.address().port()));
     EXPECT_EQ(*candidate_stats->protocol, candidate.protocol());
     EXPECT_EQ(*candidate_stats->candidate_type,
-              CandidateTypeToRTCIceCandidateType(candidate.type()));
+              CandidateTypeToRTCIceCandidateTypeForTesting(candidate.type()));
     EXPECT_EQ(*candidate_stats->priority,
               static_cast<int32_t>(candidate.priority()));
     // TODO(hbos): Define candidate_stats->url. crbug.com/632723
     EXPECT_FALSE(candidate_stats->url.is_defined());
     return candidate_stats;
   }
 
   void ExpectReportContainsCandidatePair(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const cricket::TransportStats& transport_stats) {
@@ skipping 70 matching lines @@
       EXPECT_EQ(*cert_stats.base64_certificate, cert_info.pems[i]);
       if (i + 1 < cert_info.fingerprints.size()) {
         EXPECT_EQ(*cert_stats.issuer_certificate_id,
                   "RTCCertificate_" + cert_info.fingerprints[i + 1]);
       } else {
         EXPECT_FALSE(cert_stats.issuer_certificate_id.is_defined());
       }
     }
   }
 
+  void ExpectReportContainsDataChannel(
+      const rtc::scoped_refptr<const RTCStatsReport>& report,
+      const DataChannel& data_channel) {
+    const RTCStats* stats = report->Get("RTCDataChannel_" +
+                                        rtc::ToString<>(data_channel.id()));
+    EXPECT_TRUE(stats);
+    const RTCDataChannelStats& data_channel_stats =
+        stats->cast_to<const RTCDataChannelStats>();
+    EXPECT_EQ(*data_channel_stats.label, data_channel.label());
+    EXPECT_EQ(*data_channel_stats.protocol, data_channel.protocol());
+    EXPECT_EQ(*data_channel_stats.datachannelid, data_channel.id());
+    EXPECT_EQ(*data_channel_stats.state,
+        DataStateToRTCDataChannelStateForTesting(data_channel.state()));
+    EXPECT_EQ(*data_channel_stats.messages_sent, data_channel.messages_sent());
+    EXPECT_EQ(*data_channel_stats.bytes_sent, data_channel.bytes_sent());
+    EXPECT_EQ(*data_channel_stats.messages_received,
+              data_channel.messages_received());
+    EXPECT_EQ(*data_channel_stats.bytes_received,
+              data_channel.bytes_received());
+  }
+
  protected:
   rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_;
   rtc::scoped_refptr<RTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTest, SingleCallback) {
   rtc::scoped_refptr<const RTCStatsReport> result;
   collector_->GetStatsReport(StatsCallback::Create(&result));
   EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs);
 }
@@ skipping 185 matching lines @@
         if (transport_name == "transport")
           return remote_certinfo->certificate->ssl_certificate().GetReference();
         return static_cast<rtc::SSLCertificate*>(nullptr);
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCertificateInfo(report, *local_certinfo.get());
   ExpectReportContainsCertificateInfo(report, *remote_certinfo.get());
 }
 
+TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
+  test_->data_channels().push_back(
+      new MockDataChannel(0, DataChannelInterface::kConnecting));
+  test_->data_channels().push_back(
+      new MockDataChannel(1, DataChannelInterface::kOpen));
+  test_->data_channels().push_back(
+      new MockDataChannel(2, DataChannelInterface::kClosing));
+  test_->data_channels().push_back(
+      new MockDataChannel(3, DataChannelInterface::kClosed));
+
+  rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[0]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[1]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[2]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[3]);
+
+  test_->data_channels().clear();
+  test_->data_channels().push_back(
+      new MockDataChannel(0, DataChannelInterface::kConnecting,
+                          1, 2, 3, 4));
+  test_->data_channels().push_back(
+      new MockDataChannel(1, DataChannelInterface::kOpen,
+                          5, 6, 7, 8));
+  test_->data_channels().push_back(
+      new MockDataChannel(2, DataChannelInterface::kClosing,
+                          9, 10, 11, 12));
+  test_->data_channels().push_back(
+      new MockDataChannel(3, DataChannelInterface::kClosed,
+                          13, 14, 15, 16));
+
+  collector_->ClearCachedStatsReport();
+  report = GetStatsReport();
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[0]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[1]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[2]);
+  ExpectReportContainsDataChannel(report, *test_->data_channels()[3]);
+}
+
 TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
   // Candidates in the first transport stats.
   std::unique_ptr<cricket::Candidate> a_local_host = CreateFakeCandidate(
       "1.2.3.4", 5,
       "a_local_host's protocol",
       cricket::LOCAL_PORT_TYPE,
       0);
   std::unique_ptr<cricket::Candidate> a_remote_srflx = CreateFakeCandidate(
       "6.7.8.9", 10,
       "remote_srflx's protocol",
@@ skipping 96 matching lines @@
         *stats = session_stats;
         return true;
       }));
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCandidatePair(
       report, session_stats.transport_stats["transport"]);
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
-  int64_t before = rtc::TimeUTCMicros();
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
-  int64_t after = rtc::TimeUTCMicros();
   EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(),
             static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats.";
   const RTCStats* stats = report->Get("RTCPeerConnection");
   EXPECT_TRUE(stats);
-  EXPECT_LE(before, stats->timestamp_us());
-  EXPECT_LE(stats->timestamp_us(), after);
   {
     // Expected stats with no data channels
     const RTCPeerConnectionStats& pcstats =
         stats->cast_to<RTCPeerConnectionStats>();
     EXPECT_EQ(*pcstats.data_channels_opened, static_cast<uint32_t>(0));
     EXPECT_EQ(*pcstats.data_channels_closed, static_cast<uint32_t>(0));
   }
 
   test_->data_channels().push_back(
-      new MockDataChannel(DataChannelInterface::kConnecting));
+      new MockDataChannel(0, DataChannelInterface::kConnecting));
   test_->data_channels().push_back(
-      new MockDataChannel(DataChannelInterface::kOpen));
+      new MockDataChannel(1, DataChannelInterface::kOpen));
   test_->data_channels().push_back(
-      new MockDataChannel(DataChannelInterface::kClosing));
+      new MockDataChannel(2, DataChannelInterface::kClosing));
   test_->data_channels().push_back(
-      new MockDataChannel(DataChannelInterface::kClosed));
+      new MockDataChannel(3, DataChannelInterface::kClosed));
 
   collector_->ClearCachedStatsReport();
   report = GetStatsReport();
   EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(),
             static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats.";
   stats = report->Get("RTCPeerConnection");
   EXPECT_TRUE(stats);
   {
     // Expected stats with the above four data channels
     // TODO(hbos): When the |RTCPeerConnectionStats| is the number of data
@@ skipping 20 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc