Reland of Deprecate VCMPacketizationCallback::SendData and use EncodedImageCallback instead.

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.
  */
 
@@ skipping 316 matching lines @@
   EXPECT_EQ(0, test::NumHistogramSamples("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"));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp8) {
   test::ClearHistograms();
   EncodedImage encoded_image;
-  RTPVideoHeader rtp_video_header;
-  rtp_video_header.codec = kRtpVideoVp8;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
-    rtp_video_header.simulcastIdx = 0;
+    codec_info.codecSpecific.VP8.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
-    rtp_video_header.simulcastIdx = 1;
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
+    codec_info.codecSpecific.VP8.simulcastIdx = 1;
     encoded_image.qp_ = kQpIdx1;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    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"));
 }
 
 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;
-  RTPVideoHeader rtp_video_header;
-  rtp_video_header.codec = kRtpVideoVp8;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
-    rtp_video_header.simulcastIdx = 0;
+    codec_info.codecSpecific.VP8.simulcastIdx = 0;
     encoded_image.qp_ = kQpIdx0;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    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"));
 }
 
 TEST_F(SendStatisticsProxyTest, VerifyQpHistogramStats_Vp9) {
   test::ClearHistograms();
   EncodedImage encoded_image;
-  RTPVideoHeader rtp_video_header;
-  rtp_video_header.simulcastIdx = 0;
-  rtp_video_header.codec = kRtpVideoVp9;
-  rtp_video_header.codecHeader.VP9.num_spatial_layers = 2;
+  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;
-    rtp_video_header.codecHeader.VP9.spatial_idx = 0;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    codec_info.codecSpecific.VP9.spatial_idx = 0;
+    statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
     encoded_image.qp_ = kQpIdx1;
-    rtp_video_header.codecHeader.VP9.spatial_idx = 1;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    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"));
 }
 
 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;
-  RTPVideoHeader rtp_video_header;
-  rtp_video_header.simulcastIdx = 0;
-  rtp_video_header.codec = kRtpVideoVp9;
-  rtp_video_header.codecHeader.VP9.num_spatial_layers = 1;
+  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;
-    rtp_video_header.codecHeader.VP9.spatial_idx = 0;
-    statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+    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"));
 }
 
 TEST_F(SendStatisticsProxyTest, NoSubstreams) {
   uint32_t excluded_ssrc =
       std::max(
           *std::max_element(config_.rtp.ssrcs.begin(), config_.rtp.ssrcs.end()),
@@ skipping 21 matching lines @@
   EXPECT_TRUE(stats.substreams.empty());
 }
 
 TEST_F(SendStatisticsProxyTest, EncodedResolutionTimesOut) {
   static const int kEncodedWidth = 123;
   static const int kEncodedHeight = 81;
   EncodedImage encoded_image;
   encoded_image._encodedWidth = kEncodedWidth;
   encoded_image._encodedHeight = kEncodedHeight;
 
-  RTPVideoHeader rtp_video_header;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+  codec_info.codecSpecific.VP8.simulcastIdx = 0;
 
-  rtp_video_header.simulcastIdx = 0;
-  statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
-  rtp_video_header.simulcastIdx = 1;
-  statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+  statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
+  codec_info.codecSpecific.VP8.simulcastIdx = 1;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
 
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
   EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
   EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[1]].width);
   EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[1]].height);
 
   // Forward almost to timeout, this should not have removed stats.
   fake_clock_.AdvanceTimeMilliseconds(SendStatisticsProxy::kStatsTimeoutMs - 1);
   stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
   EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
 
   // Update the first SSRC with bogus RTCP stats to make sure that encoded
   // resolution still times out (no global timeout for all stats).
   RtcpStatistics rtcp_statistics;
   RtcpStatisticsCallback* rtcp_stats = statistics_proxy_.get();
   rtcp_stats->StatisticsUpdated(rtcp_statistics, config_.rtp.ssrcs[0]);
 
   // Report stats for second SSRC to make sure it's not outdated along with the
   // first SSRC.
-  rtp_video_header.simulcastIdx = 1;
-  statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+  codec_info.codecSpecific.VP8.simulcastIdx = 1;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
 
   // Forward 1 ms, reach timeout, substream 0 should have no resolution
   // reported, but substream 1 should.
   fake_clock_.AdvanceTimeMilliseconds(1);
   stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[0]].width);
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[0]].height);
   EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[1]].width);
   EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[1]].height);
 }
 
 TEST_F(SendStatisticsProxyTest, ClearsResolutionFromInactiveSsrcs) {
   static const int kEncodedWidth = 123;
   static const int kEncodedHeight = 81;
   EncodedImage encoded_image;
   encoded_image._encodedWidth = kEncodedWidth;
   encoded_image._encodedHeight = kEncodedHeight;
 
-  RTPVideoHeader rtp_video_header;
+  CodecSpecificInfo codec_info;
+  codec_info.codecType = kVideoCodecVP8;
+  codec_info.codecSpecific.VP8.simulcastIdx = 0;
 
-  rtp_video_header.simulcastIdx = 0;
-  statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
-  rtp_video_header.simulcastIdx = 1;
-  statistics_proxy_->OnSendEncodedImage(encoded_image, &rtp_video_header);
+  statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
+  codec_info.codecSpecific.VP8.simulcastIdx = 1;
+  statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
 
   statistics_proxy_->OnInactiveSsrc(config_.rtp.ssrcs[1]);
   VideoSendStream::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(kEncodedWidth, stats.substreams[config_.rtp.ssrcs[0]].width);
   EXPECT_EQ(kEncodedHeight, stats.substreams[config_.rtp.ssrcs[0]].height);
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].width);
   EXPECT_EQ(0, stats.substreams[config_.rtp.ssrcs[1]].height);
 }
 
 TEST_F(SendStatisticsProxyTest, ClearsBitratesFromInactiveSsrcs) {
@@ skipping 225 matching lines @@
 
   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"));
 }
 
 }  // namespace webrtc