RTCDataChannelStats added.

webrtc/stats/rtcstats_objects.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/stats/rtcstats_objects.h"
 
 namespace webrtc {
 
+const char* RTCDataChannelState::kConnecting = "connecting";
+const char* RTCDataChannelState::kOpen = "open";
+const char* RTCDataChannelState::kClosing = "closing";
+const char* RTCDataChannelState::kClosed = "closed";
+
 const char* RTCStatsIceCandidatePairState::kFrozen = "frozen";
 const char* RTCStatsIceCandidatePairState::kWaiting = "waiting";
 const char* RTCStatsIceCandidatePairState::kInProgress = "inprogress";
 const char* RTCStatsIceCandidatePairState::kFailed = "failed";
 const char* RTCStatsIceCandidatePairState::kSucceeded = "succeeded";
 const char* RTCStatsIceCandidatePairState::kCancelled = "cancelled";
 
 // Strings defined in https://tools.ietf.org/html/rfc5245.
 const char* RTCIceCandidateType::kHost = "host";
 const char* RTCIceCandidateType::kSrflx = "srflx";
@@ skipping 186 matching lines @@
     : RTCStats(other.id(), other.timestamp_us()),
       fingerprint(other.fingerprint),
       fingerprint_algorithm(other.fingerprint_algorithm),
       base64_certificate(other.base64_certificate),
       issuer_certificate_id(other.issuer_certificate_id) {
 }
 
 RTCCertificateStats::~RTCCertificateStats() {
 }
 
+WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel",
+    &label,
+    &protocol,
+    &datachannelid,
+    &state,
+    &messages_sent,
+    &bytes_sent,
+    &messages_received,
+    &bytes_received);
+
+RTCDataChannelStats::RTCDataChannelStats(
+    const std::string& id, int64_t timestamp_us)
+    : RTCDataChannelStats(std::string(id), timestamp_us) {
+}
+
+RTCDataChannelStats::RTCDataChannelStats(
+    std::string&& id, int64_t timestamp_us)
+    : RTCStats(std::move(id), timestamp_us),
+      label("label"),
+      protocol("protocol"),
+      datachannelid("datachannelid"),
+      state("state"),
+      messages_sent("messagesSent"),
+      bytes_sent("bytesSent"),
+      messages_received("messagesReceived"),
+      bytes_received("bytesReceived") {
+}
+
+RTCDataChannelStats::RTCDataChannelStats(
+    const RTCDataChannelStats& other)
+    : RTCStats(other.id(), other.timestamp_us()),
+      label(other.label),
+      protocol(other.protocol),
+      datachannelid(other.datachannelid),
+      state(other.state),
+      messages_sent(other.messages_sent),
+      bytes_sent(other.bytes_sent),
+      messages_received(other.messages_received),
+      bytes_received(other.bytes_received) {
+}
+
+RTCDataChannelStats::~RTCDataChannelStats() {
+}
+
 WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection",
     &data_channels_opened,
     &data_channels_closed);
 
 RTCPeerConnectionStats::RTCPeerConnectionStats(
     const std::string& id, int64_t timestamp_us)
     : RTCPeerConnectionStats(std::string(id), timestamp_us) {
 }
 
 RTCPeerConnectionStats::RTCPeerConnectionStats(
     std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       data_channels_opened("dataChannelsOpened"),
       data_channels_closed("dataChannelsClosed") {
 }
 
 RTCPeerConnectionStats::RTCPeerConnectionStats(
     const RTCPeerConnectionStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       data_channels_opened(other.data_channels_opened),
       data_channels_closed(other.data_channels_closed) {
 }
 
 RTCPeerConnectionStats::~RTCPeerConnectionStats() {
 }
 
 }  // namespace webrtc