Add a ParseHeader method to RtcpPacket, for parsing common RTCP header.

webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
index 77520b633bc9de3eced7e4824137f3b320c03844..3c3adb510dbaee8f322949357c24d95ab5a786c2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc
@@ -13,6 +13,8 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include "webrtc/base/checks.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 
@@ -43,10 +45,87 @@ using webrtc::rtcp::Xr;
 using webrtc::test::RtcpPacketParser;
 
 namespace webrtc {
+namespace rtcp {
 
 const uint32_t kSenderSsrc = 0x12345678;
 const uint32_t kRemoteSsrc = 0x23456789;
 
+// Override RtcpPacket so we can test protected methods.
+class RtcpPacketHeaderTest : public ::testing::Test, protected RtcpPacket {
+ public:
+  RtcpPacketHeaderTest() { memset(buffer, 0, kBufferCapacity); }
+
+  virtual ~RtcpPacketHeaderTest() {}
+
+  bool Create(uint8_t* packet,
+              size_t* index,
+              size_t max_length,
+              PacketReadyCallback* callback) const override {
+    RTC_NOTREACHED();
+    return false;
+  }
+
+  size_t BlockLength() const { return 0; }
+
+ protected:
+  static const size_t kHeaderSize = 4;
+  static const size_t kBufferCapacity = 40;

[åsapersson, 2015/09/08 10:20:41]

kHeaderSize -> kHeaderSizeInBytes
kBufferCapacity -> kBufferCapacityInBytes

[sprang_webrtc, 2015/09/09 09:18:53]

Done.

+  uint8_t buffer[kBufferCapacity];
+  RTCPUtility::RtcpCommonHeader header;
+};
+

[åsapersson, 2015/09/08 10:20:41]

I think these parsing tests should be where the parsing code is, for example in
rtcp_utility_unittest.cc (while RtcpPacket is for building packets).

[sprang_webrtc, 2015/09/09 09:18:53]

Fair enough. My long (long) term hope is to rewrite rtcp_receiver to use these
packets as well. But let's do that when/if it happens.

+TEST_F(RtcpPacketHeaderTest, HeaderSize) {

[åsapersson, 2015/09/08 10:20:41]

Maybe rename to something like TooShortHeaderSize.

[sprang_webrtc, 2015/09/09 09:18:54]

Renamed to TooSmallBuffer.

+  // Buffer needs to be able to hold the header.
+  for (size_t i = 0; i < kHeaderSize; ++i)
+    EXPECT_FALSE(RtcpParseCommonHeader(buffer, 0, i, &header));
+}
+
+TEST_F(RtcpPacketHeaderTest, Version) {
+  // Version 2 is the only allowed for now.
+  for (int v = 0; v < 4; ++v) {
+    buffer[0] = v << 6;
+    EXPECT_EQ(v == 2, RtcpParseCommonHeader(buffer, 0, kHeaderSize, &header));
+  }
+}
+
+TEST_F(RtcpPacketHeaderTest, PacketSize) {
+  // Set v = 2, leave p, fmt, pt as 0.
+  buffer[0] = 2 << 6;
+
+  const size_t kBlockSize = 3;
+  ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], kBlockSize);
+  const size_t kSizeInBytes = (kBlockSize + 1) * 4;
+
+  EXPECT_FALSE(RtcpParseCommonHeader(buffer, 0, kSizeInBytes - 1, &header));
+  EXPECT_TRUE(RtcpParseCommonHeader(buffer, 0, kSizeInBytes, &header));
+}
+
+TEST_F(RtcpPacketHeaderTest, PayloadSize) {
+  // Set v = 2, p = 1, but leave fmt, pt as 0.
+  buffer[0] = (2 << 6) | (1 << 5);
+
+  const size_t kBlockSize = 3;
+  ByteWriter<uint16_t>::WriteBigEndian(&buffer[2], kBlockSize);
+  const size_t kSizeInBytes = (kBlockSize + 1) * 4;
+  const size_t kPayloadSize = kSizeInBytes - kHeaderSize;

[åsapersson, 2015/09/08 10:20:41]

kPayloadSize -> kPayloadSizeInBytes

[sprang_webrtc, 2015/09/09 09:18:53]

Done.

+
+  // Padding one byte larger than possible.
+  buffer[kSizeInBytes - 1] = kPayloadSize + 1;
+  EXPECT_FALSE(RtcpParseCommonHeader(buffer, 0, kSizeInBytes, &header));
+
+  // Pure padding packet?
+  buffer[kSizeInBytes - 1] = kPayloadSize;
+  EXPECT_TRUE(RtcpParseCommonHeader(buffer, 0, kSizeInBytes, &header));
+  EXPECT_EQ(0u, header.payload_size_bytes);
+
+  // Single byte of actual data.
+  buffer[kSizeInBytes - 1] = kPayloadSize - 1;
+  EXPECT_TRUE(RtcpParseCommonHeader(buffer, 0, kSizeInBytes, &header));
+  EXPECT_EQ(1u, header.payload_size_bytes);
+}
+
+TEST_F(RtcpPacketHeaderTest, FormatAndPayloadType) {}

[åsapersson, 2015/09/08 10:20:41]

remove

[sprang_webrtc, 2015/09/09 09:18:53]

Or implement :)

+
 TEST(RtcpPacketTest, Rr) {
   ReceiverReport rr;
   rr.From(kSenderSsrc);
@@ -1085,4 +1164,5 @@ TEST(RtcpPacketTest, XrWithTooManyBlocks) {
   EXPECT_FALSE(xr.WithVoipMetric(&voip_metric));
 }
 
+}  // namespace rtcp
 }  // namespace webrtc