RTCIceCandidatePairStats added.

webrtc/api/rtcstatscollector.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 162 matching lines @@
        callbacks_) {
     callback->OnStatsDelivered(cached_report_);
   }
   callbacks_.clear();
 }
 
 void RTCStatsCollector::ProduceCertificateStats_s(
     int64_t timestamp_us, const SessionStats& session_stats,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
-  for (const auto& transport : session_stats.transport_stats) {
+  for (const auto& transport_stats : session_stats.transport_stats) {
     rtc::scoped_refptr<rtc::RTCCertificate> local_certificate;
     if (pc_->session()->GetLocalCertificate(
-        transport.second.transport_name, &local_certificate)) {
+        transport_stats.second.transport_name, &local_certificate)) {
       ProduceCertificateStatsFromSSLCertificateAndChain_s(
           timestamp_us, local_certificate->ssl_certificate(), report);
     }
     std::unique_ptr<rtc::SSLCertificate> remote_certificate =
         pc_->session()->GetRemoteSSLCertificate(
-            transport.second.transport_name);
+            transport_stats.second.transport_name);
     if (remote_certificate) {
       ProduceCertificateStatsFromSSLCertificateAndChain_s(
           timestamp_us, *remote_certificate.get(), report);
     }
   }
 }
 
 void RTCStatsCollector::ProduceCertificateStatsFromSSLCertificateAndChain_s(
     int64_t timestamp_us, const rtc::SSLCertificate& certificate,
     RTCStatsReport* report) const {
@@ skipping 12 matching lines @@
       prev_stats->issuer_certificate_id = stats->id();
     report->AddStats(std::unique_ptr<RTCCertificateStats>(stats));
     prev_stats = stats;
   }
 }
 
 void RTCStatsCollector::ProduceIceCandidateAndPairStats_s(
       int64_t timestamp_us, const SessionStats& session_stats,
       RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
-  for (const auto& transport : session_stats.transport_stats) {
-    for (const auto& channel : transport.second.channel_stats) {
-      for (const cricket::ConnectionInfo& info : channel.connection_infos) {
-        // TODO(hbos): Produce |RTCIceCandidatePairStats| referencing the
-        // resulting |RTCIceCandidateStats| pair. crbug.com/633550
+  for (const auto& transport_stats : session_stats.transport_stats) {
+    for (const auto& channel_stats : transport_stats.second.channel_stats) {
+      int connection_id = 0;
+      for (const cricket::ConnectionInfo& info :
+           channel_stats.connection_infos) {
+        // TODO(hbos): The ID should be based on the object used to produce it.
+        // If another connection is removed, that should not affect this ID. As
+        // is, removing a connection info decrements the |connection_id| of all
+        // subsequent connections. crbug.com/633550

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

A pair can be uniquely identified by the candidates that form it. So you should
be able to form the ID by appending the IDs of the candidates.

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

Good thinkin'! Done.

+        const std::string& id = "RTCTransportChannel_" +
+            transport_stats.second.transport_name + "_" +
+            rtc::ToString<>(channel_stats.component) + "_Connection_" +
+            rtc::ToString<>(connection_id);
+        std::unique_ptr<RTCIceCandidatePairStats> candidate_pair_stats(
+            new RTCIceCandidatePairStats(id, timestamp_us));
+
+        // TODO(hbos): Set all of the |RTCIceCandidatePairStats|'s members,
+        // crbug.com/633550.
+
+        // TODO(hbos): Set candidate_pair_stats->transport_id. Should be ID to
+        // RTCTransportStats which does not exist yet: crbug.com/653873.
+
         // TODO(hbos): There could be other candidates that are not paired with
         // anything. We don't have a complete list. Local candidates come from
         // Port objects, and prflx candidates (both local and remote) are only
         // stored in candidate pairs. crbug.com/632723
-        ProduceIceCandidateStats_s(
+        candidate_pair_stats->local_candidate_id = ProduceIceCandidateStats_s(
             timestamp_us, info.local_candidate, true, report);
-        ProduceIceCandidateStats_s(
+        candidate_pair_stats->remote_candidate_id = ProduceIceCandidateStats_s(
             timestamp_us, info.remote_candidate, false, report);
+
+        // TODO(hbos): Set candidate_pair_stats->state.
+        // TODO(hbos): Set candidate_pair_stats->priority.
+        // TODO(hbos): Set candidate_pair_stats->nominated.
+        candidate_pair_stats->writable = info.writable;

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

Our "writable" doesn't currently match the definition in the spec. Our
"writable" goes to false after a certain amount of time without a response
passes.

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

Acknowledged. Wrote a TODO comment.

+        // TODO(hbos): Set candidate_pair_stats->readable.
+        candidate_pair_stats->bytes_sent =
+            static_cast<uint64_t>(info.sent_total_bytes);
+        candidate_pair_stats->bytes_received =
+            static_cast<uint64_t>(info.recv_total_bytes);
+        // TODO(hbos): Set candidate_pair_stats->total_rtt.
+        candidate_pair_stats->current_rtt =
+            static_cast<double>(info.rtt) / 1000.0;

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

I'm pretty sure "current_rtt" means the very last RTT measurement, but our RTT
is smoothed. So there's also a discrepancy here.

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

Ack. Wrote a comment.

+        // TODO(hbos): Set candidate_pair_stats->available_outgoing_bitrate.
+        // TODO(hbos): Set candidate_pair_stats->available_incoming_bitrate.
+        // TODO(hbos): Set candidate_pair_stats->requests_received.
+        // TODO(hbos): Set candidate_pair_stats->requests_sent.
+        // TODO(hbos): Set candidate_pair_stats->responses_received.
+        // TODO(hbos): Set candidate_pair_stats->responses_sent.
+        // TODO(hbos): Set candidate_pair_stats->retransmissions_received.
+        // TODO(hbos): Set candidate_pair_stats->retransmissions_sent.
+        // TODO(hbos): Set candidate_pair_stats->consent_requests_received.
+        // TODO(hbos): Set candidate_pair_stats->consent_requests_sent.
+        // TODO(hbos): Set candidate_pair_stats->consent_responses_received.
+        // TODO(hbos): Set candidate_pair_stats->consent_responses_sent.
+
+        report->AddStats(std::move(candidate_pair_stats));
+
+        ++connection_id;
       }
     }
   }
 }
 
 const std::string& RTCStatsCollector::ProduceIceCandidateStats_s(
     int64_t timestamp_us, const cricket::Candidate& candidate, bool is_local,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   const std::string& id = "RTCIceCandidate_" + candidate.id();
   const RTCStats* stats = report->Get(id);
   if (!stats) {
     std::unique_ptr<RTCIceCandidateStats> candidate_stats;
-    if (is_local) {
-      candidate_stats.reset(
-          new RTCLocalIceCandidateStats(id, timestamp_us));
-    } else {
-      candidate_stats.reset(
-          new RTCRemoteIceCandidateStats(id, timestamp_us));
-    }
+    if (is_local)
+      candidate_stats.reset(new RTCLocalIceCandidateStats(id, timestamp_us));
+    else
+      candidate_stats.reset(new RTCRemoteIceCandidateStats(id, timestamp_us));
     candidate_stats->ip = candidate.address().ipaddr().ToString();
     candidate_stats->port = static_cast<int32_t>(candidate.address().port());
     candidate_stats->protocol = candidate.protocol();
     candidate_stats->candidate_type = CandidateTypeToRTCIceCandidateType(
         candidate.type());
     candidate_stats->priority = static_cast<int32_t>(candidate.priority());
     // TODO(hbos): Define candidate_stats->url. crbug.com/632723
 
     stats = candidate_stats.get();
     report->AddStats(std::move(candidate_stats));
@@ skipping 20 matching lines @@
   // constant.
   std::unique_ptr<RTCPeerConnectionStats> stats(
     new RTCPeerConnectionStats("RTCPeerConnection", timestamp_us));
   stats->data_channels_opened = data_channels_opened;
   stats->data_channels_closed = static_cast<uint32_t>(data_channels.size()) -
                                 data_channels_opened;
   report->AddStats(std::move(stats));
 }
 
 }  // namespace webrtc