Replace RTCPUtility RTCPParser with TestRtcpParser

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 12 matching lines @@
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/fakevideorenderer.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
@@ skipping 347 matching lines @@
 }
 
 #endif  // defined(WEBRTC_END_TO_END_H264_TESTS)
 
 TEST_F(EndToEndTest, ReceiverUsesLocalSsrc) {
   class SyncRtcpObserver : public test::EndToEndTest {
    public:
     SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
-      uint32_t ssrc = 0;
-      ssrc |= static_cast<uint32_t>(packet[4]) << 24;
-      ssrc |= static_cast<uint32_t>(packet[5]) << 16;
-      ssrc |= static_cast<uint32_t>(packet[6]) << 8;
-      ssrc |= static_cast<uint32_t>(packet[7]) << 0;
-      EXPECT_EQ(kReceiverLocalVideoSsrc, ssrc);
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
+      EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc());
       observation_complete_.Set();
 
       return SEND_PACKET;
     }
 
     void PerformTest() override {
       EXPECT_TRUE(Wait())
           << "Timed out while waiting for a receiver RTCP packet to be sent.";
     }
   } test;
@@ skipping 45 matching lines @@
         --packets_left_to_drop_;
         dropped_packets_.insert(header.sequenceNumber);
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
-
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kRtpfbNack) {
-          --nacks_left_;
-          break;
-        }
-        packet_type = parser.Iterate();
-      }
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
+      nacks_left_ -= parser.nack()->num_packets();
       return SEND_PACKET;
     }
 
     void ModifyVideoConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
@@ skipping 527 matching lines @@
         highest_dropped_timestamp_ = header.timestamp;
         --frames_to_drop_;
         return DROP_PACKET;
       }
 
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
-
-      for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-           packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
-           packet_type = parser.Iterate()) {
-        if (!nack_enabled_)
-          EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kRtpfbNack);
-
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbPli) {
-          received_pli_ = true;
-          break;
-        }
-      }
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
+      if (!nack_enabled_)
+        EXPECT_EQ(0, parser.nack()->num_packets());
+      if (parser.pli()->num_packets() > 0)
+        received_pli_ = true;
       return SEND_PACKET;
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
       rtc::CritScope lock(&crit_);
       if (received_pli_ &&
           video_frame.timestamp() > highest_dropped_timestamp_) {
         observation_complete_.Set();
       }
       if (!received_pli_)
@@ skipping 106 matching lines @@
    private:
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       if (++sent_rtp_ % 3 == 0)
         return DROP_PACKET;
 
       return SEND_PACKET;
     }
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       ++sent_rtcp_;
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
 
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      bool has_report_block = false;
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        EXPECT_NE(RTCPUtility::RTCPPacketTypes::kSr, packet_type);
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
-          has_report_block = true;
-          break;
-        }
-        packet_type = parser.Iterate();
-      }
+      EXPECT_EQ(0, parser.sender_report()->num_packets());
 
       switch (rtcp_mode_) {
         case RtcpMode::kCompound:
-          if (!has_report_block) {
+          if (parser.receiver_report()->num_packets() == 0) {
             ADD_FAILURE() << "Received RTCP packet without receiver report for "
                              "RtcpMode::kCompound.";
             observation_complete_.Set();
           }
 
           if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
             observation_complete_.Set();
 
           break;
         case RtcpMode::kReducedSize:
-          if (!has_report_block)
+          if (parser.receiver_report()->num_packets() == 0)
             observation_complete_.Set();
           break;
         case RtcpMode::kOff:
           RTC_NOTREACHED();
           break;
       }
 
       return SEND_PACKET;
     }
 
@@ skipping 422 matching lines @@
     return SEND_PACKET;
   }
 
   Action OnReceiveRtcp(const uint8_t* data, size_t length) override {
     if (HasTransportFeedback(data, length))
       observation_complete_.Set();
     return SEND_PACKET;
   }
 
   bool HasTransportFeedback(const uint8_t* data, size_t length) const {
-    RTCPUtility::RTCPParserV2 parser(data, length, true);
-    EXPECT_TRUE(parser.IsValid());
-
-    RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-    while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-      if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback)
-        return true;
-      packet_type = parser.Iterate();
-    }
-
-    return false;
+    test::RtcpPacketParser parser;
+    EXPECT_TRUE(parser.Parse(data, length));
+    return parser.transport_feedback()->num_packets() > 0;
   }
 
   void PerformTest() override {
     const int64_t kDisabledFeedbackTimeoutMs = 5000;
     EXPECT_EQ(feedback_enabled_,
               observation_complete_.Wait(feedback_enabled_
                                              ? test::CallTest::kDefaultTimeoutMs
                                              : kDisabledFeedbackTimeoutMs));
   }
 
@@ skipping 132 matching lines @@
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
   class RembObserver : public test::EndToEndTest {
    public:
     RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
 
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
 
-      bool received_psfb = false;
-      bool received_remb = false;
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRemb) {
-          const RTCPUtility::RTCPPacket& packet = parser.Packet();
-          EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalVideoSsrc);
-          received_psfb = true;
-        } else if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRembItem) {
-          const RTCPUtility::RTCPPacket& packet = parser.Packet();
-          EXPECT_GT(packet.REMBItem.BitRate, 0u);
-          EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
-          EXPECT_EQ(packet.REMBItem.SSRCs[0], kVideoSendSsrcs[0]);
-          received_remb = true;
-        }
-        packet_type = parser.Iterate();
+      if (parser.remb()->num_packets() > 0) {
+        EXPECT_EQ(kReceiverLocalVideoSsrc, parser.remb()->sender_ssrc());
+        EXPECT_LT(0U, parser.remb()->bitrate_bps());
+        EXPECT_EQ(1U, parser.remb()->ssrcs().size());
+        EXPECT_EQ(kVideoSendSsrcs[0], parser.remb()->ssrcs()[0]);
+        observation_complete_.Set();
       }
-      if (received_psfb && received_remb)
-        observation_complete_.Set();
+
       return SEND_PACKET;
     }
     void PerformTest() override {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for a "
                              "receiver RTCP REMB packet to be "
                              "sent.";
     }
   } test;
 
   RunBaseTest(&test);
@@ skipping 542 matching lines @@
           enable_rrtr_(enable_rrtr),
           sent_rtcp_sr_(0),
           sent_rtcp_rr_(0),
           sent_rtcp_rrtr_(0),
           sent_rtcp_dlrr_(0) {}
 
    private:
     // Receive stream should send RR packets (and RRTR packets if enabled).
     Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
 
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
-          ++sent_rtcp_rr_;
-        } else if (packet_type ==
-                   RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime) {
+      sent_rtcp_rr_ += parser.receiver_report()->num_packets();
+      EXPECT_EQ(0, parser.sender_report()->num_packets());
+      EXPECT_GE(1, parser.xr()->num_packets());
+      if (parser.xr()->num_packets() > 0) {
+        if (parser.xr()->rrtr())
           ++sent_rtcp_rrtr_;
-        }
-        EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kSr);
-        EXPECT_NE(packet_type,
-                  RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem);
-        packet_type = parser.Iterate();
+        EXPECT_FALSE(parser.xr()->dlrr());
       }
+
       return SEND_PACKET;
     }
     // Send stream should send SR packets (and DLRR packets if enabled).
     Action OnSendRtcp(const uint8_t* packet, size_t length) override {
       rtc::CritScope lock(&crit_);
-      RTCPUtility::RTCPParserV2 parser(packet, length, true);
-      EXPECT_TRUE(parser.IsValid());
+      test::RtcpPacketParser parser;
+      EXPECT_TRUE(parser.Parse(packet, length));
 
-      RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
-      while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
-        if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
-          ++sent_rtcp_sr_;
-        } else if (packet_type ==
-                   RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem) {
+      sent_rtcp_sr_ += parser.sender_report()->num_packets();
+      EXPECT_GE(1, parser.xr()->num_packets());
+      if (parser.xr()->num_packets() > 0) {
+        EXPECT_FALSE(parser.xr()->rrtr());
+        if (parser.xr()->dlrr())
           ++sent_rtcp_dlrr_;
-        }
-        EXPECT_NE(packet_type,
-                  RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime);
-        packet_type = parser.Iterate();
       }
+
       if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
           sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve) {
         if (enable_rrtr_) {
-          EXPECT_GT(sent_rtcp_rrtr_, 0);
-          EXPECT_GT(sent_rtcp_dlrr_, 0);
+          EXPECT_LT(0, sent_rtcp_rrtr_);
+          EXPECT_LT(0, sent_rtcp_dlrr_);
         } else {
           EXPECT_EQ(0, sent_rtcp_rrtr_);
           EXPECT_EQ(0, sent_rtcp_dlrr_);
         }
         observation_complete_.Set();
       }
       return SEND_PACKET;
     }
 
     void ModifyVideoConfigs(
@@ skipping 1522 matching lines @@
     std::unique_ptr<VideoEncoder> encoder_;
     std::unique_ptr<VideoDecoder> decoder_;
     rtc::CriticalSection crit_;
     int recorded_frames_ GUARDED_BY(crit_);
   } test(this);
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc