RTCDataChannelStats 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.
  */
 
 #include "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/webrtcsession.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/sslidentity.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/port.h"
 
 namespace webrtc {
 
+namespace {
+
 const char* CandidateTypeToRTCIceCandidateType(const std::string& type) {
   if (type == cricket::LOCAL_PORT_TYPE)
     return RTCIceCandidateType::kHost;
   if (type == cricket::STUN_PORT_TYPE)
     return RTCIceCandidateType::kSrflx;
   if (type == cricket::PRFLX_PORT_TYPE)
     return RTCIceCandidateType::kPrflx;
   if (type == cricket::RELAY_PORT_TYPE)
     return RTCIceCandidateType::kRelay;
   RTC_NOTREACHED();
   return nullptr;
 }
 
+const char* DataStateToRTCDataChannelState(
+    DataChannelInterface::DataState state) {
+  switch (state) {
+    case DataChannelInterface::kConnecting:
+      return RTCDataChannelState::kConnecting;
+    case DataChannelInterface::kOpen:
+      return RTCDataChannelState::kOpen;
+    case DataChannelInterface::kClosing:
+      return RTCDataChannelState::kClosing;
+    case DataChannelInterface::kClosed:
+      return RTCDataChannelState::kClosed;
+    default:
+      RTC_NOTREACHED();
+      return nullptr;
+  }
+}
+
+}  // namespace
+
 rtc::scoped_refptr<RTCStatsCollector> RTCStatsCollector::Create(
     PeerConnection* pc, int64_t cache_lifetime_us) {
   return rtc::scoped_refptr<RTCStatsCollector>(
       new rtc::RefCountedObject<RTCStatsCollector>(pc, cache_lifetime_us));
 }
 
 RTCStatsCollector::RTCStatsCollector(PeerConnection* pc,
                                      int64_t cache_lifetime_us)
     : pc_(pc),
       signaling_thread_(pc->session()->signaling_thread()),
@@ skipping 55 matching lines @@
     int64_t timestamp_us) {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
 
   SessionStats session_stats;
   if (pc_->session()->GetTransportStats(&session_stats)) {
     ProduceCertificateStats_s(timestamp_us, session_stats, report.get());
     ProduceIceCandidateAndPairStats_s(timestamp_us, session_stats,
                                       report.get());
   }
+  ProduceDataChannelStats_s(timestamp_us, report.get());
   ProducePeerConnectionStats_s(timestamp_us, report.get());
 
   AddPartialResults(report);
 }
 
 void RTCStatsCollector::ProducePartialResultsOnWorkerThread(
     int64_t timestamp_us) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
 
@@ skipping 87 matching lines @@
     stats->fingerprint = s->fingerprint;
     stats->fingerprint_algorithm = s->fingerprint_algorithm;
     stats->base64_certificate = s->base64_certificate;
     if (prev_stats)
       prev_stats->issuer_certificate_id = stats->id();
     report->AddStats(std::unique_ptr<RTCCertificateStats>(stats));
     prev_stats = stats;
   }
 }
 
+void RTCStatsCollector::ProduceDataChannelStats_s(
+    int64_t timestamp_us, RTCStatsReport* report) const {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  const std::vector<rtc::scoped_refptr<DataChannel>>& data_channels =

[Taylor Brandstetter, 2016/10/18 17:28:11]

nit: Don't need this temporary variable, could just put
pc_->sctp_data_channels() in the for statement.

[hbos, 2016/10/18 19:13:37]

Done.

+      pc_->sctp_data_channels();
+  for (const rtc::scoped_refptr<DataChannel>& data_channel : data_channels) {
+    std::unique_ptr<RTCDataChannelStats> data_channel_stats(
+        new RTCDataChannelStats(
+            "RTCDataChannel_" + rtc::ToString<>(data_channel->id()),
+            timestamp_us));
+    data_channel_stats->label = data_channel->label();
+    data_channel_stats->protocol = data_channel->protocol();
+    data_channel_stats->datachannelid = data_channel->id();
+    data_channel_stats->state =
+        DataStateToRTCDataChannelState(data_channel->state());
+    data_channel_stats->messages_sent = data_channel->messages_sent();
+    data_channel_stats->bytes_sent = data_channel->bytes_sent();
+    data_channel_stats->messages_received = data_channel->messages_received();
+    data_channel_stats->bytes_received = data_channel->bytes_received();
+    report->AddStats(std::move(data_channel_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_stats : session_stats.transport_stats) {
     for (const auto& channel_stats : transport_stats.second.channel_stats) {
       for (const cricket::ConnectionInfo& info :
            channel_stats.connection_infos) {
         const std::string& id = "RTCIceCandidatePair_" +
             info.local_candidate.id() + "_" + info.remote_candidate.id();
@@ skipping 99 matching lines @@
   // There is always just one |RTCPeerConnectionStats| so its |id| can be a
   // 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));
 }
 
+const char* CandidateTypeToRTCIceCandidateTypeForTesting(
+    const std::string& type) {
+  return CandidateTypeToRTCIceCandidateType(type);
+}
+
+const char* DataStateToRTCDataChannelStateForTesting(
+    DataChannelInterface::DataState state) {
+  return DataStateToRTCDataChannelState(state);
+}
+
 }  // namespace webrtc