Use rtcp class instead of RTCPUtility parser for rtcp_sender_unittest

webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc

 /*
  *  Copyright (c) 2012 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 <memory>
 
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/common_types.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_transport.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::Invoke;
-using webrtc::RTCPUtility::RtcpCommonHeader;
 
 namespace webrtc {
 
 TEST(NACKStringBuilderTest, TestCase1) {
   NACKStringBuilder builder;
   builder.PushNACK(5);
   builder.PushNACK(7);
   builder.PushNACK(9);
   builder.PushNACK(10);
   builder.PushNACK(11);
@@ skipping 746 matching lines @@
 
 // This test is written to verify that BYE is always the last packet
 // type in a RTCP compoud packet.  The rtcp_sender_ is recreated with
 // mock_transport, which is used to check for whether BYE at the end
 // of a RTCP compound packet.
 TEST_F(RtcpSenderTest, ByeMustBeLast) {
   MockTransport mock_transport;
   EXPECT_CALL(mock_transport, SendRtcp(_, _))
     .WillOnce(Invoke([](const uint8_t* data, size_t len) {
     const uint8_t* next_packet = data;
-    while (next_packet < data + len) {
-      RtcpCommonHeader header;
-      RtcpParseCommonHeader(next_packet, len - (next_packet - data), &header);
-      next_packet = next_packet +
-        header.payload_size_bytes +
-        RtcpCommonHeader::kHeaderSizeBytes;
-      if (header.packet_type == RTCPUtility::PT_BYE) {
-        bool is_last_packet = (data + len == next_packet);
-        EXPECT_TRUE(is_last_packet) <<
-          "Bye packet should be last in a compound RTCP packet.";
-      }
+    const uint8_t* const packet_end = data + len;
+    rtcp::CommonHeader packet;
+    while (next_packet < packet_end) {
+      EXPECT_TRUE(packet.Parse(next_packet, packet_end - next_packet));
+      next_packet = packet.NextPacket();
+      if (packet.type() == rtcp::Bye::kPacketType)  // Main test expectation.
+        EXPECT_EQ(0, packet_end - next_packet)
+            << "Bye packet should be last in a compound RTCP packet.";
+      if (next_packet == packet_end)  // Validate test was set correctly.
+        EXPECT_EQ(packet.type(), rtcp::Bye::kPacketType)
+            << "Last packet in this test expected to be Bye.";
     }
 
     return true;
   }));
 
   // Re-configure rtcp_sender_ with mock_transport_
   rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
                                     nullptr, nullptr, &mock_transport));
   rtcp_sender_->SetSSRC(kSenderSsrc);
   rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
   rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
   rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds());
 
   // Set up XR VoIP metric to be included with BYE
   rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
   RTCPVoIPMetric metric;
   EXPECT_EQ(0, rtcp_sender_->SetRTCPVoIPMetrics(&metric));
   EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
 }
 
 }  // namespace webrtc