Correct stats for RTCPeerConnectionStats.dataChannels[Opened/Closed].

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 452 matching lines @@
 
         report->AddStats(std::move(candidate_pair_stats));
       }
     }
   }
 }
 
 void RTCStatsCollector::ProducePeerConnectionStats_s(
     int64_t timestamp_us, RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
-  // TODO(hbos): If data channels are removed from the peer connection this will
-  // yield incorrect counts. Address before closing crbug.com/636818. See
-  // https://w3c.github.io/webrtc-stats/webrtc-stats.html#pcstats-dict*.
-  uint32_t data_channels_opened = 0;
-  const std::vector<rtc::scoped_refptr<DataChannel>>& data_channels =
-      pc_->sctp_data_channels();
-  for (const rtc::scoped_refptr<DataChannel>& data_channel : data_channels) {
-    if (data_channel->state() == DataChannelInterface::kOpen)
-      ++data_channels_opened;
-  }
-  // 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;
+  stats->data_channels_opened = internal_record_.data_channels_opened;
+  stats->data_channels_closed = internal_record_.data_channels_closed;
   report->AddStats(std::move(stats));
 }
 
 void RTCStatsCollector::ProduceRTPStreamStats_s(
     int64_t timestamp_us, const SessionStats& session_stats,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
 
   // Audio
   if (pc_->session()->voice_channel()) {
@@ skipping 168 matching lines @@
     if (remote_certificate) {
       certificate_stats_pair.remote = remote_certificate->GetStats();
     }
     transport_cert_stats.insert(
         std::make_pair(transport_stats.second.transport_name,
                        std::move(certificate_stats_pair)));
   }
   return transport_cert_stats;
 }
 
+void RTCStatsCollector::OnDataChannelOpened(DataChannel* channel) {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  bool result = internal_record_.opened_data_channels.insert(
+      reinterpret_cast<uintptr_t>(channel)).second;
+  ++internal_record_.data_channels_opened;
+  RTC_DCHECK(result);
+}
+
+void RTCStatsCollector::OnDataChannelClosed(DataChannel* channel) {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  // Only channels that have been fully opened (and have increased the
+  // |data_channels_opened_| counter) increase the closed counter.
+  if (internal_record_.opened_data_channels.find(
+          reinterpret_cast<uintptr_t>(channel)) !=
+      internal_record_.opened_data_channels.end()) {
+    ++internal_record_.data_channels_closed;
+  }
+}
+
+void RTCStatsCollector::OnDataChannelOpenedForTesting(DataChannel* channel) {
+  OnDataChannelOpened(channel);
+}
+
+void RTCStatsCollector::OnDataChannelClosedForTesting(DataChannel* channel) {
+  OnDataChannelClosed(channel);
+}
+
 const char* CandidateTypeToRTCIceCandidateTypeForTesting(
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc