Add instrumentation to track the IceEndpointType.

talk/app/webrtc/fakemetricsobserver.cc

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 18 matching lines @@
 #include "webrtc/base/checks.h"
 
 namespace webrtc {
 
 FakeMetricsObserver::FakeMetricsObserver() {
   Reset();
 }
 
 void FakeMetricsObserver::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  memset(counters_, 0, sizeof(counters_));
+  counters_ = std::vector<std::vector<int>>();
   memset(int_histogram_samples_, 0, sizeof(int_histogram_samples_));
   for (std::string& type : string_histogram_samples_) {
     type.clear();
   }
 }
 
-void FakeMetricsObserver::IncrementCounter(PeerConnectionMetricsCounter type) {
+void FakeMetricsObserver::IncrementEnumCounter(
+    PeerConnectionEnumCounterType type,
+    int counter,
+    int counter_max) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  ++counters_[type];
+  if (counters_.size() <= static_cast<size_t>(type)) {
+    counters_.resize(type + 1);
+  }

[pthatcher1, 2015/08/18 18:06:22]

Why not just initialize the size in the constructor to the max size, like you do
the array?

[guoweis_webrtc, 2015/08/18 22:33:57]

each counter type's max is different.

+  if (counters_[type].size() < static_cast<size_t>(counter_max)) {

[pthatcher1, 2015/08/18 18:06:22]

It might be more readable to use a reference:

auto& counters = counters_[type];

[guoweis_webrtc, 2015/08/18 22:33:56]

sounds good.

+    counters_[type].resize(counter_max);
+  }
+  ++counters_[type][counter];
 }
 
 void FakeMetricsObserver::AddHistogramSample(PeerConnectionMetricsName type,
     int value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(int_histogram_samples_[type], 0);
   int_histogram_samples_[type] = value;
 }
 
 void FakeMetricsObserver::AddHistogramSample(PeerConnectionMetricsName type,
     const std::string& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   string_histogram_samples_[type].assign(value);
 }
 
-int FakeMetricsObserver::GetCounter(PeerConnectionMetricsCounter type) const {
+int FakeMetricsObserver::GetCounter(PeerConnectionEnumCounterType type,
+                                    int counter) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return counters_[type];
+  return counters_[type][counter];

[pthatcher1, 2015/08/18 18:06:22]

Won't this explode without a size check?

[guoweis_webrtc, 2015/08/18 22:33:56]

add a DCHECK. I don't want to return silently. It's a bug somewhere else if this
happens.

[pthatcher1, 2015/08/19 02:47:52]

But that only protects debug builds.  I think we should also protect release
builds, with something like:

if (counters_.size() <= type || counters_[type].size() <= counter) {
  return 0;  // or -1?
}

[pthatcher2, 2015/08/19 18:39:41]

If we want a crash in release builds, then make it  a CHECK instead of a DCHECK.

 }
 
 int FakeMetricsObserver::GetIntHistogramSample(
     PeerConnectionMetricsName type) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return int_histogram_samples_[type];
 }
 
 const std::string& FakeMetricsObserver::GetStringHistogramSample(
     PeerConnectionMetricsName type) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return string_histogram_samples_[type];
 }
 
 }  // namespace webrtc