Add a default implementation in metrics_default.cc of histograms methods in system_wrappers/interfac

webrtc/video/send_statistics_proxy_unittest.cc

 /*
  *  Copyright (c) 2013 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/video/send_statistics_proxy.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/system_wrappers/include/metrics.h"
-#include "webrtc/test/histogram.h"
+#include "webrtc/system_wrappers/include/metrics_default.h"
 
 namespace webrtc {
 namespace {
 const uint32_t kFirstSsrc = 17;
 const uint32_t kSecondSsrc = 42;
 const uint32_t kFirstRtxSsrc = 18;
 const uint32_t kSecondRtxSsrc = 43;
 
 const int kMinRequiredSamples = 200;
 const int kQpIdx0 = 21;
 const int kQpIdx1 = 39;
 }  // namespace
 
 class SendStatisticsProxyTest : public ::testing::Test {
  public:
   SendStatisticsProxyTest()
       : fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
         max_delay_ms_(0) {}
   virtual ~SendStatisticsProxyTest() {}
 
  protected:
   virtual void SetUp() {
+    metrics::Reset();
     statistics_proxy_.reset(new SendStatisticsProxy(
         &fake_clock_, GetTestConfig(),
         VideoEncoderConfig::ContentType::kRealtimeVideo));
     expected_ = VideoSendStream::Stats();
   }
 
   VideoSendStream::Config GetTestConfig() {
     VideoSendStream::Config config(nullptr);
     config.rtp.ssrcs.push_back(kFirstSsrc);
     config.rtp.ssrcs.push_back(kSecondSsrc);
@@ skipping 225 matching lines @@
   CpuOveruseMetrics metrics;
   metrics.encode_usage_percent = 80;
   statistics_proxy_->OnEncodedFrameTimeMeasured(kEncodeTimeMs, metrics);
 
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kEncodeTimeMs, stats.avg_encode_time_ms);
   EXPECT_EQ(metrics.encode_usage_percent, stats.encode_usage_percent);
 }
 
 TEST_F(SendStatisticsProxyTest, SwitchContentTypeUpdatesHistograms) {
-  test::ClearHistograms();
   const int kWidth = 640;
   const int kHeight = 480;
 
   for (int i = 0; i < kMinRequiredSamples; ++i)
     statistics_proxy_->OnIncomingFrame(kWidth, kHeight);
 
   // No switch, stats not should be updated.
   statistics_proxy_->SetContentType(
       VideoEncoderConfig::ContentType::kRealtimeVideo);
-  EXPECT_EQ(0, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
+  EXPECT_EQ(0, metrics::NumSamples("WebRTC.Video.InputWidthInPixels"));
 
   // Switch to screenshare, real-time stats should be updated.
   statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InputWidthInPixels"));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8) {
-  test::ClearHistograms();
   EncodedImage encoded_image;
   CodecSpecificInfo codec_info;
   codec_info.codecType = kVideoCodecVP8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     codec_info.codecSpecific.VP8.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
     codec_info.codecSpecific.VP8.simulcastIdx = 1;
     encoded_image.qp_ = kQpIdx1;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   }
   statistics_proxy_.reset();
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S0"));
-  EXPECT_EQ(kQpIdx0,
-            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S0"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8.S1"));
-  EXPECT_EQ(kQpIdx1,
-            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8.S1"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8.S0"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8.S0", kQpIdx0));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8.S1"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8.S1", kQpIdx1));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8OneSsrc) {
   VideoSendStream::Config config(nullptr);
   config.rtp.ssrcs.push_back(kFirstSsrc);
   statistics_proxy_.reset(new SendStatisticsProxy(
       &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo));
 
-  test::ClearHistograms();
   EncodedImage encoded_image;
   CodecSpecificInfo codec_info;
   codec_info.codecType = kVideoCodecVP8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     codec_info.codecSpecific.VP8.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   }
   statistics_proxy_.reset();
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp8"));
-  EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp8"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp8"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp8", kQpIdx0));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9) {
-  test::ClearHistograms();
   EncodedImage encoded_image;
   CodecSpecificInfo codec_info;
   codec_info.codecType = kVideoCodecVP9;
   codec_info.codecSpecific.VP9.num_spatial_layers = 2;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     encoded_image.qp_ = kQpIdx0;
     codec_info.codecSpecific.VP9.spatial_idx = 0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
     encoded_image.qp_ = kQpIdx1;
     codec_info.codecSpecific.VP9.spatial_idx = 1;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   }
   statistics_proxy_.reset();
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S0"));
-  EXPECT_EQ(kQpIdx0,
-            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S0"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9.S1"));
-  EXPECT_EQ(kQpIdx1,
-            test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9.S1"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9.S0"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9.S0", kQpIdx0));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9.S1"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9.S1", kQpIdx1));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9OneSpatialLayer) {
   VideoSendStream::Config config(nullptr);
   config.rtp.ssrcs.push_back(kFirstSsrc);
   statistics_proxy_.reset(new SendStatisticsProxy(
       &fake_clock_, config, VideoEncoderConfig::ContentType::kRealtimeVideo));
 
-  test::ClearHistograms();
   EncodedImage encoded_image;
   CodecSpecificInfo codec_info;
   codec_info.codecType = kVideoCodecVP9;
   codec_info.codecSpecific.VP9.num_spatial_layers = 1;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     encoded_image.qp_ = kQpIdx0;
     codec_info.codecSpecific.VP9.spatial_idx = 0;
     statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
   }
   statistics_proxy_.reset();
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.Encoded.Qp.Vp9"));
-  EXPECT_EQ(kQpIdx0, test::LastHistogramSample("WebRTC.Video.Encoded.Qp.Vp9"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.Encoded.Qp.Vp9"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.Encoded.Qp.Vp9", kQpIdx0));
 }
 
 TEST_F(SendStatisticsProxyTest, NoSubstreams) {
   uint32_t excluded_ssrc =
       std::max(
           *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
           *std::max_element(config_.rtp.rtx.ssrcs.begin(),
                             config_.rtp.rtx.ssrcs.end())) +
       1;
   // From RtcpStatisticsCallback.
@@ skipping 121 matching lines @@
   counters.pli_packets += 3 * metrics::kMinRunTimeInSeconds;
   counters.unique_nack_requests += 4 * metrics::kMinRunTimeInSeconds;
   counters.nack_requests += 5 * metrics::kMinRunTimeInSeconds;
 
   proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
   proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
 
   // Changing content type causes histograms to be reported.
   statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.NackPacketsReceivedPerMinute"));
-  EXPECT_EQ(
-      1, test::NumHistogramSamples("WebRTC.Video.FirPacketsReceivedPerMinute"));
-  EXPECT_EQ(
-      1, test::NumHistogramSamples("WebRTC.Video.PliPacketsReceivedPerMinute"));
-  EXPECT_EQ(1, test::NumHistogramSamples(
+  EXPECT_EQ(1,
+            metrics::NumSamples("WebRTC.Video.NackPacketsReceivedPerMinute"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FirPacketsReceivedPerMinute"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PliPacketsReceivedPerMinute"));
+  EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
 
   const int kRate = 60 * 2;  // Packets per minute with two streams.
 
-  EXPECT_EQ(1 * kRate, test::LastHistogramSample(
-                           "WebRTC.Video.NackPacketsReceivedPerMinute"));
-  EXPECT_EQ(2 * kRate, test::LastHistogramSample(
-                           "WebRTC.Video.FirPacketsReceivedPerMinute"));
-  EXPECT_EQ(3 * kRate, test::LastHistogramSample(
-                           "WebRTC.Video.PliPacketsReceivedPerMinute"));
-  EXPECT_EQ(4 * 100 / 5,
-            test::LastHistogramSample(
-                "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.NackPacketsReceivedPerMinute",
+                                  1 * kRate));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.FirPacketsReceivedPerMinute",
+                                  2 * kRate));
+  EXPECT_EQ(1, metrics::NumEvents("WebRTC.Video.PliPacketsReceivedPerMinute",
+                                  3 * kRate));
+  EXPECT_EQ(
+      1, metrics::NumEvents("WebRTC.Video.UniqueNackRequestsReceivedInPercent",
+                            4 * 100 / 5));
 
   // New start time but same counter values.
   proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
   proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
 
   fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
 
   counters.nack_packets += 1 * metrics::kMinRunTimeInSeconds;
   counters.fir_packets += 2 * metrics::kMinRunTimeInSeconds;
   counters.pli_packets += 3 * metrics::kMinRunTimeInSeconds;
   counters.unique_nack_requests += 4 * metrics::kMinRunTimeInSeconds;
   counters.nack_requests += 5 * metrics::kMinRunTimeInSeconds;
 
   proxy->RtcpPacketTypesCounterUpdated(kFirstSsrc, counters);
   proxy->RtcpPacketTypesCounterUpdated(kSecondSsrc, counters);
 
   SetUp();  // Reset stats proxy also causes histograms to be reported.
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
+  EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute"));
-  EXPECT_EQ(1, test::NumHistogramSamples(
+  EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute"));
-  EXPECT_EQ(1, test::NumHistogramSamples(
+  EXPECT_EQ(1, metrics::NumSamples(
                    "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute"));
   EXPECT_EQ(
-      1, test::NumHistogramSamples(
+      1, metrics::NumSamples(
              "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent"));
 
-  EXPECT_EQ(1 * kRate,
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute"));
-  EXPECT_EQ(2 * kRate,
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute"));
-  EXPECT_EQ(3 * kRate,
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute"));
-  EXPECT_EQ(
-      4 * 100 / 5,
-      test::LastHistogramSample(
-          "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute",
+                   1 * kRate));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute",
+                   2 * kRate));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute",
+                   3 * kRate));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent",
+                4 * 100 / 5));
 }
 
 TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) {
   StreamDataCountersCallback* proxy =
       static_cast<StreamDataCountersCallback*>(statistics_proxy_.get());
   StreamDataCounters counters;
   StreamDataCounters rtx_counters;
   counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
@@ skipping 16 matching lines @@
 
   fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
   proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
 
   // Changing content type causes histograms to be reported.
   statistics_proxy_->SetContentType(VideoEncoderConfig::ContentType::kScreen);
 
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.BitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample("WebRTC.Video.BitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.BitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.BitrateSentInKbps",
+                static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.MediaBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.MediaBitrateSentInKbps",
+                   static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PaddingBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.PaddingBitrateSentInKbps",
+                static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
 
   EXPECT_EQ(1,
-            test::NumHistogramSamples("WebRTC.Video.MediaBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample("WebRTC.Video.MediaBitrateSentInKbps"));
+            metrics::NumSamples("WebRTC.Video.RetransmittedBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.RetransmittedBitrateSentInKbps",
+                static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
 
-  EXPECT_EQ(1,
-            test::NumHistogramSamples("WebRTC.Video.PaddingBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample("WebRTC.Video.PaddingBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps"));
+  EXPECT_EQ(
+      1, metrics::NumEvents(
+             "WebRTC.Video.RtxBitrateSentInKbps",
+             static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
+                              metrics::kMinRunTimeInSeconds / 1000)));
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.RetransmittedBitrateSentInKbps"));
-  EXPECT_EQ(
-      static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
-                       metrics::kMinRunTimeInSeconds / 1000),
-      test::LastHistogramSample("WebRTC.Video.RetransmittedBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.RtxBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample("WebRTC.Video.RtxBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.FecBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample("WebRTC.Video.FecBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.FecBitrateSentInKbps",
+                   static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
 
   // New start time but same counter values.
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
   proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
 
   // Double counter values, this should result in the same counts as before but
   // with new histogram names.
   StreamDataCounters new_counters = counters;
   new_counters.Add(counters);
   StreamDataCounters new_rtx_counters = rtx_counters;
   new_rtx_counters.Add(rtx_counters);
 
   fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
   proxy->DataCountersUpdated(new_counters, kFirstSsrc);
   proxy->DataCountersUpdated(new_counters, kSecondSsrc);
   proxy->DataCountersUpdated(new_rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(new_rtx_counters, kSecondRtxSsrc);
 
   SetUp();  // Reset stats proxy also causes histograms to be reported.
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.BitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumSamples("WebRTC.Video.Screenshare.BitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.Screenshare.BitrateSentInKbps",
+                static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.Screenshare.MediaBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.Screenshare.MediaBitrateSentInKbps",
+                   static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps",
+                static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples(
+                   "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps",
+                static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
   EXPECT_EQ(
-      static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
-                       metrics::kMinRunTimeInSeconds / 1000),
-      test::LastHistogramSample("WebRTC.Video.Screenshare.BitrateSentInKbps"));
+      1, metrics::NumSamples("WebRTC.Video.Screenshare.RtxBitrateSentInKbps"));
+  EXPECT_EQ(
+      1, metrics::NumEvents(
+             "WebRTC.Video.Screenshare.RtxBitrateSentInKbps",
+             static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
+                              metrics::kMinRunTimeInSeconds / 1000)));
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.MediaBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.MediaBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.PaddingBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.RetransmittedBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.RtxBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.RtxBitrateSentInKbps"));
-
-  EXPECT_EQ(1, test::NumHistogramSamples(
-                   "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
-  EXPECT_EQ(static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
-                             metrics::kMinRunTimeInSeconds / 1000),
-            test::LastHistogramSample(
-                "WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
+  EXPECT_EQ(
+      1, metrics::NumSamples("WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.Screenshare.FecBitrateSentInKbps",
+                   static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
 }
 
 }  // namespace webrtc