RTCIceCandidatePairStats.available[Outgoing/Incoming]Bitrate collected.

webrtc/pc/rtcstats_integrationtest.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 241 matching lines @@
     return stats_types;
   }
 
   explicit RTCStatsReportVerifier(const RTCStatsReport* report)
       : report_(report) {
   }
 
   void VerifyReport() {
     std::set<const char*> missing_stats = StatsTypes();
     bool verify_successful = true;
+    std::vector<const RTCTransportStats*> transport_stats =
+        report_->GetStatsOfType<RTCTransportStats>();
+    EXPECT_EQ(transport_stats.size(), 1);
+    std::string selected_candidate_pair_id =
+        *transport_stats[0]->selected_candidate_pair_id;
     for (const RTCStats& stats : *report_) {
       missing_stats.erase(stats.type());
       if (stats.type() == RTCCertificateStats::kType) {
         verify_successful &= VerifyRTCCertificateStats(
             stats.cast_to<RTCCertificateStats>());
       } else if (stats.type() == RTCCodecStats::kType) {
         verify_successful &= VerifyRTCCodecStats(
             stats.cast_to<RTCCodecStats>());
       } else if (stats.type() == RTCDataChannelStats::kType) {
         verify_successful &= VerifyRTCDataChannelStats(
             stats.cast_to<RTCDataChannelStats>());
       } else if (stats.type() == RTCIceCandidatePairStats::kType) {
         verify_successful &= VerifyRTCIceCandidatePairStats(
-            stats.cast_to<RTCIceCandidatePairStats>());
+            stats.cast_to<RTCIceCandidatePairStats>(),
+            stats.id() == selected_candidate_pair_id);
       } else if (stats.type() == RTCLocalIceCandidateStats::kType) {
         verify_successful &= VerifyRTCLocalIceCandidateStats(
             stats.cast_to<RTCLocalIceCandidateStats>());
       } else if (stats.type() == RTCRemoteIceCandidateStats::kType) {
         verify_successful &= VerifyRTCRemoteIceCandidateStats(
             stats.cast_to<RTCRemoteIceCandidateStats>());
       } else if (stats.type() == RTCMediaStreamStats::kType) {
         verify_successful &= VerifyRTCMediaStreamStats(
             stats.cast_to<RTCMediaStreamStats>());
       } else if (stats.type() == RTCMediaStreamTrackStats::kType) {
@@ skipping 58 matching lines @@
     verifier.TestMemberIsDefined(data_channel.datachannelid);
     verifier.TestMemberIsDefined(data_channel.state);
     verifier.TestMemberIsNonNegative<uint32_t>(data_channel.messages_sent);
     verifier.TestMemberIsNonNegative<uint64_t>(data_channel.bytes_sent);
     verifier.TestMemberIsNonNegative<uint32_t>(data_channel.messages_received);
     verifier.TestMemberIsNonNegative<uint64_t>(data_channel.bytes_received);
     return verifier.ExpectAllMembersSuccessfullyTested();
   }
 
   bool VerifyRTCIceCandidatePairStats(
-      const RTCIceCandidatePairStats& candidate_pair) {
+      const RTCIceCandidatePairStats& candidate_pair, bool is_selected_pair) {
     RTCStatsVerifier verifier(report_, &candidate_pair);
     verifier.TestMemberIsIDReference(
         candidate_pair.transport_id, RTCTransportStats::kType);
     verifier.TestMemberIsIDReference(
         candidate_pair.local_candidate_id, RTCLocalIceCandidateStats::kType);
     verifier.TestMemberIsIDReference(
         candidate_pair.remote_candidate_id, RTCRemoteIceCandidateStats::kType);
     verifier.TestMemberIsDefined(candidate_pair.state);
     verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.priority);
     verifier.TestMemberIsUndefined(candidate_pair.nominated);
     verifier.TestMemberIsDefined(candidate_pair.writable);
     verifier.TestMemberIsUndefined(candidate_pair.readable);
     verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_sent);
     verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.bytes_received);
     verifier.TestMemberIsUndefined(candidate_pair.total_round_trip_time);
     verifier.TestMemberIsNonNegative<double>(
         candidate_pair.current_round_trip_time);
-    verifier.TestMemberIsUndefined(candidate_pair.available_outgoing_bitrate);
+    if (is_selected_pair) {
+      verifier.TestMemberIsNonNegative<double>(
+          candidate_pair.available_outgoing_bitrate);
+    } else {
+      verifier.TestMemberIsUndefined(candidate_pair.available_outgoing_bitrate);
+    }
     verifier.TestMemberIsUndefined(candidate_pair.available_incoming_bitrate);
     verifier.TestMemberIsNonNegative<uint64_t>(
         candidate_pair.requests_received);
     verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.requests_sent);
     verifier.TestMemberIsNonNegative<uint64_t>(
         candidate_pair.responses_received);
     verifier.TestMemberIsNonNegative<uint64_t>(candidate_pair.responses_sent);
     verifier.TestMemberIsUndefined(candidate_pair.retransmissions_received);
     verifier.TestMemberIsUndefined(candidate_pair.retransmissions_sent);
     verifier.TestMemberIsUndefined(candidate_pair.consent_requests_received);
@@ skipping 242 matching lines @@
   caller_ = nullptr;
   // Any pending stats requests should have completed in the act of destroying
   // the peer connection.
   EXPECT_TRUE(stats_obtainer->report());
 }
 #endif  // HAVE_SCTP
 
 }  // namespace
 
 }  // namespace webrtc