Refactor: Move RTCStatsCollector helper functions to anonymous namespace

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 53 matching lines @@
     case DataChannelInterface::kClosing:
       return RTCDataChannelState::kClosing;
     case DataChannelInterface::kClosed:
       return RTCDataChannelState::kClosed;
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
 }
 
+void ProduceCertificateStatsFromSSLCertificateStats(
+    int64_t timestamp_us, const rtc::SSLCertificateStats& certificate_stats,
+    RTCStatsReport* report) {
+  RTCCertificateStats* prev_certificate_stats = nullptr;
+  for (const rtc::SSLCertificateStats* s = &certificate_stats; s;
+       s = s->issuer.get()) {
+    RTCCertificateStats* certificate_stats = new RTCCertificateStats(
+        RTCCertificateIDFromFingerprint(s->fingerprint), timestamp_us);
+    certificate_stats->fingerprint = s->fingerprint;
+    certificate_stats->fingerprint_algorithm = s->fingerprint_algorithm;
+    certificate_stats->base64_certificate = s->base64_certificate;
+    if (prev_certificate_stats)
+      prev_certificate_stats->issuer_certificate_id = certificate_stats->id();
+    report->AddStats(std::unique_ptr<RTCCertificateStats>(certificate_stats));
+    prev_certificate_stats = certificate_stats;
+  }
+}
+
+const std::string& ProduceIceCandidateStats(
+    int64_t timestamp_us, const cricket::Candidate& candidate, bool is_local,
+    RTCStatsReport* report) {
+  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));
+    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());
+
+    stats = candidate_stats.get();
+    report->AddStats(std::move(candidate_stats));
+  }
+  RTC_DCHECK_EQ(stats->type(), is_local ? RTCLocalIceCandidateStats::kType
+                                        : RTCRemoteIceCandidateStats::kType);
+  return stats->id();
+}
+
 }  // 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)
@@ skipping 135 matching lines @@
   }
   callbacks_.clear();
 }
 
 void RTCStatsCollector::ProduceCertificateStats_s(
     int64_t timestamp_us,
     const std::map<std::string, CertificateStatsPair>& transport_cert_stats,
     RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   for (const auto& kvp : transport_cert_stats) {
     if (kvp.second.local) {

[hta-webrtc, 2016/10/28 11:27:33]

Did I really let you get away with naming a local variable "kvp"....?

[hbos, 2016/10/28 11:41:02]

Yes :D Bwahaha. Okay, renamed.

-      ProduceCertificateStatsFromSSLCertificateStats_s(
+      ProduceCertificateStatsFromSSLCertificateStats(
           timestamp_us, *kvp.second.local.get(), report);
     }
     if (kvp.second.remote) {
-      ProduceCertificateStatsFromSSLCertificateStats_s(
+      ProduceCertificateStatsFromSSLCertificateStats(
           timestamp_us, *kvp.second.remote.get(), report);
     }
   }
 }
 
-void RTCStatsCollector::ProduceCertificateStatsFromSSLCertificateStats_s(
-    int64_t timestamp_us, const rtc::SSLCertificateStats& certificate_stats,
-    RTCStatsReport* report) const {
-  RTC_DCHECK(signaling_thread_->IsCurrent());
-  RTCCertificateStats* prev_certificate_stats = nullptr;
-  for (const rtc::SSLCertificateStats* s = &certificate_stats; s;
-       s = s->issuer.get()) {
-    RTCCertificateStats* certificate_stats = new RTCCertificateStats(
-        RTCCertificateIDFromFingerprint(s->fingerprint), timestamp_us);
-    certificate_stats->fingerprint = s->fingerprint;
-    certificate_stats->fingerprint_algorithm = s->fingerprint_algorithm;
-    certificate_stats->base64_certificate = s->base64_certificate;
-    if (prev_certificate_stats)
-      prev_certificate_stats->issuer_certificate_id = certificate_stats->id();
-    report->AddStats(std::unique_ptr<RTCCertificateStats>(certificate_stats));
-    prev_certificate_stats = certificate_stats;
-  }
-}
-
 void RTCStatsCollector::ProduceDataChannelStats_s(
     int64_t timestamp_us, RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   for (const rtc::scoped_refptr<DataChannel>& data_channel :
        pc_->sctp_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();
@@ skipping 19 matching lines @@
            channel_stats.connection_infos) {
         std::unique_ptr<RTCIceCandidatePairStats> candidate_pair_stats(
             new RTCIceCandidatePairStats(
                 RTCIceCandidatePairStatsIDFromConnectionInfo(info),
                 timestamp_us));
 
         // 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
-        candidate_pair_stats->local_candidate_id = ProduceIceCandidateStats_s(
+        candidate_pair_stats->local_candidate_id = ProduceIceCandidateStats(
             timestamp_us, info.local_candidate, true, report);
-        candidate_pair_stats->remote_candidate_id = ProduceIceCandidateStats_s(
+        candidate_pair_stats->remote_candidate_id = ProduceIceCandidateStats(
             timestamp_us, info.remote_candidate, false, report);
 
         // TODO(hbos): This writable is different than the spec. It goes to
         // false after a certain amount of time without a response passes.
         // crbug.com/633550
         candidate_pair_stats->writable = info.writable;
         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): The |info.rtt| measurement is smoothed. It shouldn't be
         // smoothed according to the spec. crbug.com/633550. See
         // https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-currentrtt
         candidate_pair_stats->current_rtt =
             static_cast<double>(info.rtt) / 1000.0;
         candidate_pair_stats->requests_sent =
             static_cast<uint64_t>(info.sent_ping_requests_total);
         candidate_pair_stats->responses_received =
             static_cast<uint64_t>(info.recv_ping_responses);
         candidate_pair_stats->responses_sent =
             static_cast<uint64_t>(info.sent_ping_responses);
 
         report->AddStats(std::move(candidate_pair_stats));
       }
     }
   }
 }
 
-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));
-    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());
-
-    stats = candidate_stats.get();
-    report->AddStats(std::move(candidate_stats));
-  }
-  RTC_DCHECK_EQ(stats->type(), is_local ? RTCLocalIceCandidateStats::kType
-                                        : RTCRemoteIceCandidateStats::kType);
-  return stats->id();
-}
-
 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) {
@@ skipping 106 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc