[Splitting] TMMBRHelp class simplifted (and disappear because become too simple)

webrtc/modules/rtp_rtcp/source/rtcp_receiver_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.
  */
 
@@ skipping 1012 matching lines @@
   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
   EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size()));
   system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
   EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
   EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
   system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
   EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
-  // This call is expected to fail because no data has arrived.
-  EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0u, rtcp_receiver_->TMMBRReceived().size());
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
   rtc::Buffer packet = compound.Build();
   EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
 
-  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
-  TMMBRSet candidate_set;
-  candidate_set.VerifyAndAllocateSet(1);
-  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
-  EXPECT_LT(0U, candidate_set.Tmmbr(0));
-  EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0));
+  std::vector<rtcp::TmmbItem> candidate_set = rtcp_receiver_->TMMBRReceived();
+  EXPECT_EQ(1u, candidate_set.size());
+  EXPECT_LT(0U, candidate_set[0].bitrate_bps());
+  EXPECT_EQ(kSenderSsrc, candidate_set[0].ssrc());
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   // This SSRC is not what we are sending.
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
   rtc::Buffer packet = compound.Build();
 
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
   EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0u, rtcp_receiver_->TMMBRReceived().size());
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0));
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
   rtc::Buffer packet = compound.Build();
 
   EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0u, rtcp_receiver_->TMMBRReceived().size());
 }
 
 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);  // Matches "media source" above.
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
 
   // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
   // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
   for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
     rtcp::Tmmbr tmmbr;
     tmmbr.From(ssrc);
     tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0));
 
     rtcp::SenderReport sr;
     sr.From(ssrc);
     rtcp::CompoundPacket compound;
     compound.Append(&sr);
     compound.Append(&tmmbr);
     rtc::Buffer packet = compound.Build();
     EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size()));
     // 5 seconds between each packet.
     system_clock_.AdvanceTimeMilliseconds(5000);
   }
   // It is now starttime + 15.
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
-  TMMBRSet candidate_set;
-  candidate_set.VerifyAndAllocateSet(3);
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
-  EXPECT_LT(0U, candidate_set.Tmmbr(0));
+  std::vector<rtcp::TmmbItem> candidate_set = rtcp_receiver_->TMMBRReceived();
+  EXPECT_EQ(3u, candidate_set.size());
+  EXPECT_LT(0U, candidate_set[0].bitrate_bps());
   // We expect the timeout to be 25 seconds. Advance the clock by 12
   // seconds, timing out the first packet.
   system_clock_.AdvanceTimeMilliseconds(12000);
-  // Odd behaviour: Just counting them does not trigger the timeout.
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
-  EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
-  EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
+  candidate_set = rtcp_receiver_->TMMBRReceived();
+  EXPECT_EQ(2u, candidate_set.size());
+  EXPECT_EQ(kSenderSsrc + 1, candidate_set[0].ssrc());
 }
 
 TEST_F(RtcpReceiverTest, Callbacks) {
   class RtcpCallbackImpl : public RtcpStatisticsCallback {
    public:
     RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {}
     virtual ~RtcpCallbackImpl() {}
 
     void StatisticsUpdated(const RtcpStatistics& statistics,
                            uint32_t ssrc) override {
@@ skipping 133 matching lines @@
 
   // Transport feedback should be ignored, but next packet should work.
   EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback);
   EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb);
   EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate);
 }
 
 }  // Anonymous namespace
 
 }  // namespace webrtc