[rtp_rtcp] rtcp::Tmmbn cleaned and got Parse function

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
index 32d64a97b4c68e89e36193ea43eb253e6ccc8c8f..d65af46fd7b19bd9485e57839250b7cf9a734bbc 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc
@@ -10,75 +10,108 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
-#include "webrtc/test/rtcp_packet_parser.h"
-
+using testing::ElementsAreArray;
+using testing::IsEmpty;
+using testing::make_tuple;
 using webrtc::rtcp::RawPacket;
+using webrtc::rtcp::TmmbItem;
 using webrtc::rtcp::Tmmbn;
-using webrtc::test::RtcpPacketParser;
+using webrtc::RTCPUtility::RtcpCommonHeader;
+using webrtc::RTCPUtility::RtcpParseCommonHeader;
 
 namespace webrtc {
+namespace {
 const uint32_t kSenderSsrc = 0x12345678;
 const uint32_t kRemoteSsrc = 0x23456789;
+const uint32_t kBitrateBps = 312000;
+const uint16_t kOverhead = 0x1fe;
+const uint8_t kPacket[] = {0x84, 205,  0x00, 0x04,
+                           0x12, 0x34, 0x56, 0x78,
+                           0x00, 0x00, 0x00, 0x00,
+                           0x23, 0x45, 0x67, 0x89,
+                           0x0a, 0x61, 0x61, 0xfe};
+
+bool ParseTmmbn(const uint8_t* buffer, size_t length, Tmmbn* tmmbn) {
+  RtcpCommonHeader header;
+  EXPECT_TRUE(RtcpParseCommonHeader(buffer, length, &header));
+  EXPECT_EQ(length, header.BlockSize());
+  return tmmbn->Parse(header, buffer + RtcpCommonHeader::kHeaderSizeBytes);
+}
+}  // namespace
 
-TEST(RtcpPacketTest, TmmbnWithNoItem) {
+TEST(RtcpPacketTmmbnTest, Create) {
   Tmmbn tmmbn;
   tmmbn.From(kSenderSsrc);
+  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+
+  rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
 
-  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
-  RtcpPacketParser parser;
-  parser.Parse(packet->Buffer(), packet->Length());
-  EXPECT_EQ(1, parser.tmmbn()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
-  EXPECT_EQ(0, parser.tmmbn_items()->num_packets());
+  EXPECT_THAT(make_tuple(packet->Buffer(), packet->Length()),
+              ElementsAreArray(kPacket));
 }
 
-TEST(RtcpPacketTest, TmmbnWithOneItem) {
+TEST(RtcpPacketTmmbnTest, Parse) {
   Tmmbn tmmbn;
-  tmmbn.From(kSenderSsrc);
-  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc, 312, 60));
-
-  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
-  RtcpPacketParser parser;
-  parser.Parse(packet->Buffer(), packet->Length());
-  EXPECT_EQ(1, parser.tmmbn()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
-  EXPECT_EQ(1, parser.tmmbn_items()->num_packets());
-  EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
-  EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
-  EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
+  EXPECT_TRUE(ParseTmmbn(kPacket, sizeof(kPacket), &tmmbn));
+
+  const Tmmbn& parsed = tmmbn;
+
+  EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
+  ASSERT_EQ(1u, parsed.items().size());
+  EXPECT_EQ(kRemoteSsrc, parsed.items().front().ssrc());
+  EXPECT_EQ(kBitrateBps, parsed.items().front().bitrate_bps());
+  EXPECT_EQ(kOverhead, parsed.items().front().packet_overhead());
 }
 
-TEST(RtcpPacketTest, TmmbnWithTwoItems) {
+TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
   Tmmbn tmmbn;
   tmmbn.From(kSenderSsrc);
-  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc, 312, 60));
-  EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc + 1, 1288, 40));
-
-  rtc::scoped_ptr<RawPacket> packet(tmmbn.Build());
-  RtcpPacketParser parser;
-  parser.Parse(packet->Buffer(), packet->Length());
-  EXPECT_EQ(1, parser.tmmbn()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
-  EXPECT_EQ(2, parser.tmmbn_items()->num_packets());
-  EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
-  EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
-  EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
-  EXPECT_EQ(kRemoteSsrc + 1, parser.tmmbn_items()->Ssrc(1));
-  EXPECT_EQ(1288U, parser.tmmbn_items()->BitrateKbps(1));
-  EXPECT_EQ(40U, parser.tmmbn_items()->Overhead(1));
+
+  rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
+  Tmmbn parsed;
+  EXPECT_TRUE(ParseTmmbn(packet->Buffer(), packet->Length(), &parsed));
+
+  EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
+  EXPECT_THAT(parsed.items(), IsEmpty());
 }
 
-TEST(RtcpPacketTest, TmmbnWithTooManyItems) {
+TEST(RtcpPacketTmmbnTest, CreateAndParseWithTwoItems) {
   Tmmbn tmmbn;
   tmmbn.From(kSenderSsrc);
-  const int kMaxTmmbrItems = 50;
-  for (int i = 0; i < kMaxTmmbrItems; ++i)
-    EXPECT_TRUE(tmmbn.WithTmmbr(kRemoteSsrc + i, 312, 60));
+  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40));
+
+  rtc::scoped_ptr<RawPacket> packet = tmmbn.Build();
+  Tmmbn parsed;
+  EXPECT_TRUE(ParseTmmbn(packet->Buffer(), packet->Length(), &parsed));
+
+  EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
+  EXPECT_EQ(2u, parsed.items().size());
+  EXPECT_EQ(kRemoteSsrc, parsed.items()[0].ssrc());
+  EXPECT_EQ(kBitrateBps, parsed.items()[0].bitrate_bps());
+  EXPECT_EQ(kOverhead, parsed.items()[0].packet_overhead());
+  EXPECT_EQ(kRemoteSsrc + 1, parsed.items()[1].ssrc());
+  EXPECT_EQ(4 * kBitrateBps, parsed.items()[1].bitrate_bps());
+  EXPECT_EQ(40U, parsed.items()[1].packet_overhead());
+}
 
-  EXPECT_FALSE(tmmbn.WithTmmbr(kRemoteSsrc + kMaxTmmbrItems, 312, 60));
+TEST(RtcpPacketTmmbnTest, ParseFailsOnTooSmallPacket) {
+  const uint8_t kSmallPacket[] = {0x84, 205,  0x00, 0x01,
+                                  0x12, 0x34, 0x56, 0x78};
+  Tmmbn tmmbn;
+  EXPECT_FALSE(ParseTmmbn(kSmallPacket, sizeof(kSmallPacket), &tmmbn));
 }
 
+TEST(RtcpPacketTmmbnTest, ParseFailsOnUnAlignedPacket) {
+  const uint8_t kUnalignedPacket[] = {0x84,  205, 0x00, 0x03,
+                                      0x12, 0x34, 0x56, 0x78,
+                                      0x00, 0x00, 0x00, 0x00,
+                                      0x23, 0x45, 0x67, 0x89};
+
+  Tmmbn tmmbn;
+  EXPECT_FALSE(ParseTmmbn(kUnalignedPacket, sizeof(kUnalignedPacket), &tmmbn));
+}
 }  // namespace webrtc