Migrate several call tests from legacy RtpHeaderParser to RtpPacket parsing.

Bug: None
Change-Id: I96f11922b3cd66eb02093fa7e6e4d21774c19575
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161323
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30166}

audio/audio_send_stream_tests.cc

@@ -12,6 +12,9 @@
 #include <utility>
 #include <vector>
 
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet.h"
 #include "test/call_test.h"
 #include "test/field_trial.h"
 #include "test/gtest.h"
@@ -79,17 +82,11 @@ TEST_F(AudioSendStreamCallTest, NoExtensionsByDefault) {
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+      RtpPacket rtp_packet;
+      EXPECT_TRUE(rtp_packet.Parse(packet, length));  // rtp packet is valid.
+      EXPECT_EQ(packet[0] & 0b0001'0000, 0);          // extension bit not set.
 
-      EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
-      EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
-      EXPECT_FALSE(header.extension.hasTransportSequenceNumber);
-      EXPECT_FALSE(header.extension.hasAudioLevel);
-      EXPECT_FALSE(header.extension.hasVideoRotation);
-      EXPECT_FALSE(header.extension.hasVideoContentType);
       observation_complete_.Set();
-
       return SEND_PACKET;
     }
 
@@ -111,16 +108,17 @@ TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
   class AudioLevelObserver : public AudioSendTest {
    public:
     AudioLevelObserver() : AudioSendTest() {
-      EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
-                                                      kAudioLevelExtensionId));
+      extensions_.Register<AudioLevel>(kAudioLevelExtensionId);
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+      RtpPacket rtp_packet(&extensions_);
+      EXPECT_TRUE(rtp_packet.Parse(packet, length));
 
-      EXPECT_TRUE(header.extension.hasAudioLevel);
-      if (header.extension.audioLevel != 0) {
+      uint8_t audio_level = 0;
+      bool voice = false;
+      EXPECT_TRUE(rtp_packet.GetExtension<AudioLevel>(&voice, &audio_level));
+      if (audio_level != 0) {
         // Wait for at least one packet with a non-zero level.
         observation_complete_.Set();
       } else {
@@ -142,6 +140,9 @@ TEST_F(AudioSendStreamCallTest, SupportsAudioLevel) {
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for single RTP packet.";
     }
+
+   private:
+    RtpHeaderExtensionMap extensions_;
   } test;
 
   RunBaseTest(&test);
@@ -151,20 +152,19 @@ class TransportWideSequenceNumberObserver : public AudioSendTest {
  public:
   explicit TransportWideSequenceNumberObserver(bool expect_sequence_number)
       : AudioSendTest(), expect_sequence_number_(expect_sequence_number) {
-    EXPECT_TRUE(parser_->RegisterRtpHeaderExtension(
-        kRtpExtensionTransportSequenceNumber,
-        kTransportSequenceNumberExtensionId));
+    extensions_.Register<TransportSequenceNumber>(
+        kTransportSequenceNumberExtensionId);
   }
 
  private:
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
-    RTPHeader header;
-    EXPECT_TRUE(parser_->Parse(packet, length, &header));
+    RtpPacket rtp_packet(&extensions_);
+    EXPECT_TRUE(rtp_packet.Parse(packet, length));
 
-    EXPECT_EQ(header.extension.hasTransportSequenceNumber,
+    EXPECT_EQ(rtp_packet.HasExtension<TransportSequenceNumber>(),
               expect_sequence_number_);
-    EXPECT_FALSE(header.extension.hasTransmissionTimeOffset);
-    EXPECT_FALSE(header.extension.hasAbsoluteSendTime);
+    EXPECT_FALSE(rtp_packet.HasExtension<TransmissionOffset>());
+    EXPECT_FALSE(rtp_packet.HasExtension<AbsoluteSendTime>());
 
     observation_complete_.Set();
 
@@ -184,6 +184,7 @@ class TransportWideSequenceNumberObserver : public AudioSendTest {
     EXPECT_TRUE(Wait()) << "Timed out while waiting for a single RTP packet.";
   }
   const bool expect_sequence_number_;
+  RtpHeaderExtensionMap extensions_;
 };
 
 TEST_F(AudioSendStreamCallTest, SendsTransportWideSequenceNumbersInFieldTrial) {
@@ -210,13 +211,13 @@ TEST_F(AudioSendStreamCallTest, SendDtmf) {
 
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+      RtpPacket rtp_packet;
+      EXPECT_TRUE(rtp_packet.Parse(packet, length));
 
-      if (header.payloadType == kDtmfPayloadType) {
-        EXPECT_EQ(12u, header.headerLength);
-        EXPECT_EQ(16u, length);
-        const int event = packet[12];
+      if (rtp_packet.PayloadType() == kDtmfPayloadType) {
+        EXPECT_EQ(rtp_packet.headers_size(), 12u);
+        EXPECT_EQ(rtp_packet.size(), 16u);
+        const int event = rtp_packet.payload()[0];
         if (event != expected_dtmf_event_) {
           ++expected_dtmf_event_;
           EXPECT_EQ(event, expected_dtmf_event_);

call/BUILD.gn

@@ -457,6 +457,7 @@ if (rtc_include_tests) {
       "../modules/audio_device:audio_device_impl",
       "../modules/audio_mixer:audio_mixer_impl",
       "../modules/rtp_rtcp",
+      "../modules/rtp_rtcp:rtp_rtcp_format",
       "../rtc_base",
       "../rtc_base:checks",
       "../rtc_base:rtc_base_approved",

call/call_perf_tests.cc

@@ -27,6 +27,7 @@
 #include "modules/audio_coding/include/audio_coding_module.h"
 #include "modules/audio_device/include/test_audio_device.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
+#include "modules/rtp_rtcp/source/rtp_packet.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/thread.h"
@@ -434,22 +435,23 @@ void CallPerfTest::TestCaptureNtpTime(
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, length, &header));
+      RtpPacket rtp_packet;
+      EXPECT_TRUE(rtp_packet.Parse(packet, length));
 
       if (!rtp_start_timestamp_set_) {
         // Calculate the rtp timestamp offset in order to calculate the real
         // capture time.
         uint32_t first_capture_timestamp =
             90 * static_cast<uint32_t>(capturer_->first_frame_capture_time());
-        rtp_start_timestamp_ = header.timestamp - first_capture_timestamp;
+        rtp_start_timestamp_ = rtp_packet.Timestamp() - first_capture_timestamp;
         rtp_start_timestamp_set_ = true;
       }
 
-      uint32_t capture_timestamp = header.timestamp - rtp_start_timestamp_;
+      uint32_t capture_timestamp =
+          rtp_packet.Timestamp() - rtp_start_timestamp_;
       capture_time_list_.insert(
           capture_time_list_.end(),
-          std::make_pair(header.timestamp, capture_timestamp));
+          std::make_pair(rtp_packet.Timestamp(), capture_timestamp));
       return SEND_PACKET;
     }
 

test/rtp_rtcp_observer.h

@@ -70,11 +70,9 @@ class RtpRtcpObserver {
  protected:
   RtpRtcpObserver() : RtpRtcpObserver(0) {}
   explicit RtpRtcpObserver(int event_timeout_ms)
-      : parser_(RtpHeaderParser::CreateForTest()),
-        timeout_ms_(event_timeout_ms) {}
+      : timeout_ms_(event_timeout_ms) {}
 
   rtc::Event observation_complete_;
-  const std::unique_ptr<RtpHeaderParser> parser_;
 
  private:
   const int timeout_ms_;