Add separate send-side UMA stats for screenshare and video.

webrtc/video/end_to_end_tests.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 <algorithm>
@@ skipping 63 matching lines @@
       return false;
     }
   };
 
   void DecodesRetransmittedFrame(bool use_rtx, bool use_red);
   void ReceivesPliAndRecovers(int rtp_history_ms);
   void RespectsRtcpMode(RtcpMode rtcp_mode);
   void TestXrReceiverReferenceTimeReport(bool enable_rrtr);
   void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
   void TestRtpStatePreservation(bool use_rtx);
-  void VerifyHistogramStats(bool use_rtx, bool use_red);
+  void VerifyHistogramStats(bool use_rtx, bool use_red, bool screenshare);
 };
 
 TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
   CreateCalls(Call::Config(), Call::Config());
 
   test::NullTransport transport;
   CreateSendConfig(1, &transport);
   CreateMatchingReceiveConfigs(&transport);
 
   CreateStreams();
@@ skipping 1775 matching lines @@
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.UniqueNackRequestsSentInPercent"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
   EXPECT_GT(test::LastHistogramSample(
       "WebRTC.Video.NackPacketsSentPerMinute"), 0);
   EXPECT_GT(test::LastHistogramSample(
       "WebRTC.Video.NackPacketsReceivedPerMinute"), 0);
 }
 
-void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) {
+void EndToEndTest::VerifyHistogramStats(bool use_rtx,
+                                        bool use_red,
+                                        bool screenshare) {
   class StatsObserver : public test::EndToEndTest {
    public:
-    StatsObserver(bool use_rtx, bool use_red)
+    StatsObserver(bool use_rtx, bool use_red, bool screenshare)
         : EndToEndTest(kLongTimeoutMs),
           use_rtx_(use_rtx),
           use_red_(use_red),
+          screenshare_(screenshare),
           sender_call_(nullptr),
           receiver_call_(nullptr),
           start_runtime_ms_(-1) {}
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       if (MinMetricRunTimePassed())
         observation_complete_->Set();
 
       // GetStats calls GetSendChannelRtcpStatistics
@@ skipping 30 matching lines @@
       }
       // RTX
       if (use_rtx_) {
         send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
         send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
         (*receive_configs)[0].rtp.rtx[kFakeSendPayloadType].ssrc =
             kSendRtxSsrcs[0];
         (*receive_configs)[0].rtp.rtx[kFakeSendPayloadType].payload_type =
             kSendRtxPayloadType;
       }
+      encoder_config->content_type =
+          screenshare_ ? VideoEncoderConfig::ContentType::kScreen
+                       : VideoEncoderConfig::ContentType::kRealtimeVideo;
     }
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       sender_call_ = sender_call;
       receiver_call_ = receiver_call;
     }
 
     void PerformTest() override {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out waiting for packet to be NACKed.";
     }
 
-    bool use_rtx_;
-    bool use_red_;
+    const bool use_rtx_;
+    const bool use_red_;
+    const bool screenshare_;
     Call* sender_call_;
     Call* receiver_call_;
     int64_t start_runtime_ms_;
-  } test(use_rtx, use_red);
+  } test(use_rtx, use_red, screenshare);
 
   test::ClearHistograms();
   RunBaseTest(&test, FakeNetworkPipe::Config());
 
   // Delete the call for Call stats to be reported.
   sender_call_.reset();
   receiver_call_.reset();
 
+  std::string video_prefix =
+      screenshare ? "WebRTC.Video.Screenshare." : "WebRTC.Video.";
+
   // Verify that stats have been updated once.
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Call.VideoBitrateReceivedInKbps"));
   EXPECT_EQ(1,
             test::NumHistogramSamples("WebRTC.Call.RtcpBitrateReceivedInBps"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Call.BitrateReceivedInKbps"));
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Call.EstimatedSendBitrateInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Call.PacerBitrateInKbps"));
 
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.NackPacketsSentPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.NackPacketsReceivedPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.FirPacketsSentPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.FirPacketsReceivedPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.PliPacketsSentPerMinute"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.PliPacketsReceivedPerMinute"));
 
-  EXPECT_EQ(1, test::NumHistogramSamples(
-      "WebRTC.Video.KeyFramesSentInPermille"));
+  EXPECT_EQ(
+      1, test::NumHistogramSamples(video_prefix + "KeyFramesSentInPermille"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.KeyFramesReceivedInPermille"));
 
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.SentPacketsLostInPercent"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.ReceivedPacketsLostInPercent"));
 
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputWidthInPixels"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputHeightInPixels"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SentWidthInPixels"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SentHeightInPixels"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "InputWidthInPixels"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "InputHeightInPixels"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentWidthInPixels"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentHeightInPixels"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.ReceivedWidthInPixels"));
   EXPECT_EQ(1,
             test::NumHistogramSamples("WebRTC.Video.ReceivedHeightInPixels"));
 
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
-            test::LastHistogramSample("WebRTC.Video.InputWidthInPixels"));
+            test::LastHistogramSample(video_prefix + "InputWidthInPixels"));
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
-            test::LastHistogramSample("WebRTC.Video.InputHeightInPixels"));
+            test::LastHistogramSample(video_prefix + "InputHeightInPixels"));
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
-            test::LastHistogramSample("WebRTC.Video.SentWidthInPixels"));
+            test::LastHistogramSample(video_prefix + "SentWidthInPixels"));
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
-            test::LastHistogramSample("WebRTC.Video.SentHeightInPixels"));
+            test::LastHistogramSample(video_prefix + "SentHeightInPixels"));
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
             test::LastHistogramSample("WebRTC.Video.ReceivedWidthInPixels"));
   EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
             test::LastHistogramSample("WebRTC.Video.ReceivedHeightInPixels"));
 
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.InputFramesPerSecond"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SentFramesPerSecond"));
+  EXPECT_EQ(1,
+            test::NumHistogramSamples(video_prefix + "InputFramesPerSecond"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SentFramesPerSecond"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.DecodedFramesPerSecond"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.RenderFramesPerSecond"));
 
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.OnewayDelayInMs"));
   EXPECT_EQ(
       1, test::NumHistogramSamples("WebRTC.Video.RenderSqrtPixelsPerSecond"));
 
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.EncodeTimeInMs"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "EncodeTimeInMs"));
   EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.DecodeTimeInMs"));
 
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.BitrateSentInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.BitrateReceivedInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.MediaBitrateSentInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.MediaBitrateReceivedInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.PaddingBitrateSentInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.PaddingBitrateReceivedInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.RetransmittedBitrateSentInKbps"));
   EXPECT_EQ(1, test::NumHistogramSamples(
       "WebRTC.Video.RetransmittedBitrateReceivedInKbps"));
 
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SendSideDelayInMs"));
-  EXPECT_EQ(1, test::NumHistogramSamples("WebRTC.Video.SendSideDelayMaxInMs"));
+  EXPECT_EQ(1, test::NumHistogramSamples(video_prefix + "SendSideDelayInMs"));
+  EXPECT_EQ(1,
+            test::NumHistogramSamples(video_prefix + "SendSideDelayMaxInMs"));
 
   int num_rtx_samples = use_rtx ? 1 : 0;
   EXPECT_EQ(num_rtx_samples, test::NumHistogramSamples(
       "WebRTC.Video.RtxBitrateSentInKbps"));
   EXPECT_EQ(num_rtx_samples, test::NumHistogramSamples(
       "WebRTC.Video.RtxBitrateReceivedInKbps"));
 
   int num_red_samples = use_red ? 1 : 0;
   EXPECT_EQ(num_red_samples, test::NumHistogramSamples(
       "WebRTC.Video.FecBitrateSentInKbps"));
   EXPECT_EQ(num_red_samples, test::NumHistogramSamples(
       "WebRTC.Video.FecBitrateReceivedInKbps"));
   EXPECT_EQ(num_red_samples, test::NumHistogramSamples(
       "WebRTC.Video.ReceivedFecPacketsInPercent"));
 }
 
 TEST_F(EndToEndTest, VerifyHistogramStatsWithRtx) {
   const bool kEnabledRtx = true;
   const bool kEnabledRed = false;
-  VerifyHistogramStats(kEnabledRtx, kEnabledRed);
+  const bool kScreenshare = false;
+  VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
 }
 
 TEST_F(EndToEndTest, VerifyHistogramStatsWithRed) {
   const bool kEnabledRtx = false;
   const bool kEnabledRed = true;
-  VerifyHistogramStats(kEnabledRtx, kEnabledRed);
+  const bool kScreenshare = false;
+  VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
+}
+
+TEST_F(EndToEndTest, VerifyHistogramStatsWithScreenshare) {
+  const bool kEnabledRtx = false;
+  const bool kEnabledRed = false;
+  const bool kScreenshare = true;
+  VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
 }
 
 void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
   static const int kNumRtcpReportPacketsToObserve = 5;
   class RtcpXrObserver : public test::EndToEndTest {
    public:
     explicit RtcpXrObserver(bool enable_rrtr)
         : EndToEndTest(kDefaultTimeoutMs),
           enable_rrtr_(enable_rrtr),
           sent_rtcp_sr_(0),
@@ skipping 1119 matching lines @@
   EXPECT_TRUE(default_receive_config.rtp.rtx.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
   EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
       << "Enabling RTP extensions require negotiation.";
 
   VerifyEmptyNackConfig(default_receive_config.rtp.nack);
   VerifyEmptyFecConfig(default_receive_config.rtp.fec);
 }
 
 }  // namespace webrtc