Add histogram stats for send delay for a sent video stream.

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/test/histogram.h"
 
 namespace webrtc {
+namespace {
+const int64_t kMaxPacketDelayMs = 11000;
+}  // 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() {
@@ skipping 249 matching lines @@
     int avg_delay_ms = ssrc;
     int max_delay_ms = ssrc + 1;
     observer->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, ssrc);
     expected_.substreams[ssrc].avg_delay_ms = avg_delay_ms;
     expected_.substreams[ssrc].max_delay_ms = max_delay_ms;
   }
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   ExpectEqual(expected_, stats);
 }
 
+TEST_F(SendStatisticsProxyTest, VerifySendDelayStats) {
+  const int64_t kSendDelayInMs = 5;
+  const size_t kMinRequiredSamples = 200;
+  test::ClearHistograms();
+  SendPacketObserver* observer = statistics_proxy_.get();
+  const uint32_t ssrc = *config_.rtp.ssrcs.begin();
+
+  uint16_t packet_id = 0;
+  for (size_t i = 0; i < kMinRequiredSamples; ++i) {
+    observer->OnSendPacket(++packet_id, fake_clock_.TimeInMilliseconds(), ssrc);
+    // Packet sent.
+    fake_clock_.AdvanceTimeMilliseconds(kSendDelayInMs);
+    EXPECT_TRUE(statistics_proxy_->OnSentPacket(packet_id));
+  }
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SendDelayInMs"));
+  EXPECT_EQ(kSendDelayInMs,
+            test::LastHistogramSample("WebRTC.Video.SendDelayInMs"));
+}
+
+TEST_F(SendStatisticsProxyTest, OnSendPacket) {
+  const uint16_t kPacketId = 2345;
+  SendPacketObserver* observer = statistics_proxy_.get();
+  const uint32_t ssrc = *config_.rtp.ssrcs.begin();
+
+  observer->OnSendPacket(kPacketId, fake_clock_.TimeInMilliseconds(), ssrc);
+  fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDelayMs - 1);
+  observer->OnSendPacket(kPacketId + 1, fake_clock_.TimeInMilliseconds(), ssrc);
+
+  EXPECT_TRUE(statistics_proxy_->OnSentPacket(kPacketId));
+  EXPECT_TRUE(statistics_proxy_->OnSentPacket(kPacketId + 1));
+  // Packets removed.
+  EXPECT_FALSE(statistics_proxy_->OnSentPacket(kPacketId));

[pbos-webrtc, 2015/12/07 06:05:52]

This can be called more than once right? If this is called both when it gets out
to talk/ from webrtc/ and when it gets put on the socket, aren't we failing to
update the actual time here (calls from libjingle's OnSentPackets are ignored).
Am I reading this wrong?

[åsapersson, 2015/12/08 12:50:15]

OnSentPacket should only be called from talk.

+  EXPECT_FALSE(statistics_proxy_->OnSentPacket(kPacketId + 1));
+}
+
+TEST_F(SendStatisticsProxyTest, OnSendPacket_RemoveOldWithWrap) {
+  SendPacketObserver* observer = statistics_proxy_.get();
+  const uint32_t ssrc = *config_.rtp.ssrcs.begin();
+
+  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
+  observer->OnSendPacket(0xFFFFu, capture_time_ms, ssrc);
+  observer->OnSendPacket(0u, capture_time_ms, ssrc);
+  observer->OnSendPacket(1u, capture_time_ms + 1, ssrc);
+  fake_clock_.AdvanceTimeMilliseconds(kMaxPacketDelayMs);
+  observer->OnSendPacket(2u, capture_time_ms + 2, ssrc);
+
+  EXPECT_FALSE(statistics_proxy_->OnSentPacket(0xFFFFu));  // Old removed.
+  EXPECT_FALSE(statistics_proxy_->OnSentPacket(0u));       // Old removed.
+  EXPECT_TRUE(statistics_proxy_->OnSentPacket(1u));
+  EXPECT_TRUE(statistics_proxy_->OnSentPacket(2u));
+}
+
 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.
   RtcpStatistics rtcp_stats;
   RtcpStatisticsCallback* rtcp_callback = statistics_proxy_.get();
@@ skipping 96 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);
 }
 
 }  // namespace webrtc