Move RTCP histograms from vie_channel to video channel stats proxies.

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.
  */
 
 // This file includes unit tests for SendStatisticsProxy.
 #include "webrtc/video/send_statistics_proxy.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/test/histogram.h"
 
 namespace webrtc {
 
+static const uint32_t kFirstSsrc = 17;
+static const uint32_t kSecondSsrc = 42;
+static const uint32_t kFirstRtxSsrc = 18;
+static const uint32_t kSecondRtxSsrc = 43;
+
 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() {
     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(17);
-    config.rtp.ssrcs.push_back(42);
-    config.rtp.rtx.ssrcs.push_back(18);
-    config.rtp.rtx.ssrcs.push_back(43);
+    config.rtp.ssrcs.push_back(kFirstSsrc);
+    config.rtp.ssrcs.push_back(kSecondSsrc);
+    config.rtp.rtx.ssrcs.push_back(kFirstRtxSsrc);
+    config.rtp.rtx.ssrcs.push_back(kSecondRtxSsrc);
     return config;
   }
 
   void ExpectEqual(VideoSendStream::Stats one, VideoSendStream::Stats other) {
     EXPECT_EQ(one.input_frame_rate, other.input_frame_rate);
     EXPECT_EQ(one.encode_frame_rate, other.encode_frame_rate);
     EXPECT_EQ(one.media_bitrate_bps, other.media_bitrate_bps);
     EXPECT_EQ(one.suspended, other.suspended);
 
     EXPECT_EQ(one.substreams.size(), other.substreams.size());
@@ skipping 25 matching lines @@
       EXPECT_EQ(a.rtp_stats.fec.packets, b.rtp_stats.fec.packets);
 
       EXPECT_EQ(a.rtcp_stats.fraction_lost, b.rtcp_stats.fraction_lost);
       EXPECT_EQ(a.rtcp_stats.cumulative_lost, b.rtcp_stats.cumulative_lost);
       EXPECT_EQ(a.rtcp_stats.extended_max_sequence_number,
                 b.rtcp_stats.extended_max_sequence_number);
       EXPECT_EQ(a.rtcp_stats.jitter, b.rtcp_stats.jitter);
     }
   }
 
+  SimulatedClock fake_clock_;
   rtc::scoped_ptr<SendStatisticsProxy> statistics_proxy_;
-  SimulatedClock fake_clock_;
   VideoSendStream::Config config_;
   int avg_delay_ms_;
   int max_delay_ms_;
   VideoSendStream::Stats expected_;
   typedef std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator
       StreamIterator;
 };
 
 TEST_F(SendStatisticsProxyTest, RtcpStatistics) {
   RtcpStatisticsCallback* callback = statistics_proxy_.get();
@@ skipping 326 matching lines @@
 
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(static_cast<int>(bitrate.bitrate_bps),
             stats.substreams[config_.rtp.ssrcs[0]].total_bitrate_bps);
   EXPECT_EQ(static_cast<int>(bitrate.bitrate_bps),
             stats.substreams[config_.rtp.ssrcs[0]].retransmit_bitrate_bps);
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].total_bitrate_bps);
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].retransmit_bitrate_bps);
 }
 
+TEST_F(SendStatisticsProxyTest, ResetsRtcpCountersOnContentChange) {
+  RtcpPacketTypeCounterObserver* proxy =
+      static_cast<RtcpPacketTypeCounterObserver*>(statistics_proxy_.get());
+  RtcpPacketTypeCounter counters;
+  counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
+  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);
+
+  // 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(
+                   "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"));
+
+  // 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(
+                   "WebRTC.Video.Screenshare.NackPacketsReceivedPerMinute"));
+  EXPECT_EQ(1, test::NumHistogramSamples(
+                   "WebRTC.Video.Screenshare.FirPacketsReceivedPerMinute"));
+  EXPECT_EQ(1, test::NumHistogramSamples(
+                   "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute"));
+  EXPECT_EQ(
+      1, test::NumHistogramSamples(
+             "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"));
+}
+
 }  // namespace webrtc