RTCIceCandidatePairStats 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 313 matching lines @@
           &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);
     return callback->report();
   }
 
-  void ExpectReportContainsCandidate(
+  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());
+    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()));
     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) {
+    for (const auto& channel_stats : transport_stats.channel_stats) {
+      int connection_id = 0;
+      for (const cricket::ConnectionInfo& info :
+           channel_stats.connection_infos) {
+        const std::string& id = "RTCTransportChannel_" +
+            transport_stats.transport_name + "_" +
+            rtc::ToString<>(channel_stats.component) + "_Connection_" +
+            rtc::ToString<>(connection_id);

[Taylor Brandstetter, 2016/10/10 21:45:38]

Should the test be relying on a specific ID format? Or just for the ID to remain
consistent over successive calls to GetStats?

[hbos, 2016/10/10 22:39:56]

I think testing the ID format is a good way to ensure it will stay consistent
and unique.

[Taylor Brandstetter, 2016/10/10 23:07:03]

It is, but it means the test will need to be updated whenever the format
changes. Which I guess is unlikely to happen, so it's not a big deal.

+        const RTCStats* stats = report->Get(id);
+        EXPECT_TRUE(stats);
+        const RTCIceCandidatePairStats& candidate_pair_stats =
+            stats->cast_to<RTCIceCandidatePairStats>();
+
+        // TODO(hbos): Define all the undefined |candidate_pair_stats| stats.
+        // crbug.com/633550
+        EXPECT_FALSE(candidate_pair_stats.transport_id.is_defined());
+        const RTCIceCandidateStats* local_candidate =
+            ExpectReportContainsCandidate(report, info.local_candidate, true);
+        EXPECT_EQ(*candidate_pair_stats.local_candidate_id,
+                  local_candidate->id());
+        const RTCIceCandidateStats* remote_candidate =
+            ExpectReportContainsCandidate(report, info.remote_candidate, false);
+        EXPECT_EQ(*candidate_pair_stats.remote_candidate_id,
+                  remote_candidate->id());
+
+        EXPECT_FALSE(candidate_pair_stats.state.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.priority.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.nominated.is_defined());
+        EXPECT_EQ(*candidate_pair_stats.writable, info.writable);
+        EXPECT_FALSE(candidate_pair_stats.readable.is_defined());
+        EXPECT_EQ(*candidate_pair_stats.bytes_sent,
+                  static_cast<uint64_t>(info.sent_total_bytes));
+        EXPECT_EQ(*candidate_pair_stats.bytes_received,
+                  static_cast<uint64_t>(info.recv_total_bytes));
+        EXPECT_FALSE(candidate_pair_stats.total_rtt.is_defined());
+        EXPECT_EQ(*candidate_pair_stats.current_rtt,
+                  static_cast<double>(info.rtt) / 1000.0);
+        EXPECT_FALSE(
+            candidate_pair_stats.available_outgoing_bitrate.is_defined());
+        EXPECT_FALSE(
+            candidate_pair_stats.available_incoming_bitrate.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.requests_received.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.requests_sent.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.responses_received.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.responses_sent.is_defined());
+        EXPECT_FALSE(
+            candidate_pair_stats.retransmissions_received.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.retransmissions_sent.is_defined());
+        EXPECT_FALSE(
+            candidate_pair_stats.consent_requests_received.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.consent_requests_sent.is_defined());
+        EXPECT_FALSE(
+            candidate_pair_stats.consent_responses_received.is_defined());
+        EXPECT_FALSE(candidate_pair_stats.consent_responses_sent.is_defined());
+      }
+    }
   }
 
   void ExpectReportContainsCertificateInfo(
       const rtc::scoped_refptr<const RTCStatsReport>& report,
       const CertificateInfo& cert_info) {
     for (size_t i = 0; i < cert_info.fingerprints.size(); ++i) {
       const RTCStats* stats = report->Get(
           "RTCCertificate_" + cert_info.fingerprints[i]);
       EXPECT_TRUE(stats);
       const RTCCertificateStats& cert_stats =
@@ skipping 286 matching lines @@
 
   rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
   ExpectReportContainsCandidate(report, *a_local_host.get(), true);
   ExpectReportContainsCandidate(report, *a_remote_srflx.get(), false);
   ExpectReportContainsCandidate(report, *a_local_prflx.get(), true);
   ExpectReportContainsCandidate(report, *a_remote_relay.get(), false);
   ExpectReportContainsCandidate(report, *b_local.get(), true);
   ExpectReportContainsCandidate(report, *b_remote.get(), false);
 }
 
+TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
+  std::unique_ptr<cricket::Candidate> local_candidate = CreateFakeCandidate(
+      "42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);
+  std::unique_ptr<cricket::Candidate> remote_candidate = CreateFakeCandidate(
+      "42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);
+
+  SessionStats session_stats;
+
+  cricket::TransportChannelStats transport_channel_stats;
+  transport_channel_stats.connection_infos.push_back(
+      cricket::ConnectionInfo());
+  transport_channel_stats.connection_infos[0].local_candidate =
+      *local_candidate.get();
+  transport_channel_stats.connection_infos[0].remote_candidate =
+      *remote_candidate.get();
+  session_stats.transport_stats["transport"].transport_name = "transport";
+  session_stats.transport_stats["transport"].channel_stats.push_back(
+      transport_channel_stats);
+
+  // Mock the session to return the desired candidates.
+  EXPECT_CALL(test_->session(), GetTransportStats(_)).WillRepeatedly(Invoke(
+      [this, &session_stats](SessionStats* stats) {
+        *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);
@@ skipping 46 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc