Revert of Wire up send-side bandwidth estimation.

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 15 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 
 namespace webrtc {
 
 namespace {  // Anonymous namespace; hide utility functions and classes.
 
 // This test transport verifies that no functions get called.
 class TestTransport : public Transport,
                       public NullRtpData {
  public:
-  explicit TestTransport() : rtcp_receiver_(nullptr) {}
+  explicit TestTransport()
+      : rtcp_receiver_(NULL) {
+  }
   void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) {
     rtcp_receiver_ = rtcp_receiver;
   }
   int SendPacket(const void* /*data*/, size_t /*len*/) override {
     ADD_FAILURE();  // FAIL() gives a compile error.
     return -1;
   }
 
   int SendRTCPPacket(const void* packet, size_t packet_len) override {
     ADD_FAILURE();
@@ skipping 22 matching lines @@
             &system_clock_,
             kRemoteBitrateEstimatorMinBitrateBps)) {
     test_transport_ = new TestTransport();
 
     RtpRtcp::Configuration configuration;
     configuration.audio = false;
     configuration.clock = &system_clock_;
     configuration.outgoing_transport = test_transport_;
     configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get();
     rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration);
-    rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr,
-                                      nullptr, nullptr, rtp_rtcp_impl_);
+    rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, NULL, NULL, NULL,
+                                      rtp_rtcp_impl_);
     test_transport_->SetRTCPReceiver(rtcp_receiver_);
   }
   ~RtcpReceiverTest() {
     delete rtcp_receiver_;
     delete rtp_rtcp_impl_;
     delete test_transport_;
   }
 
   // Injects an RTCP packet into the receiver.
   // Returns 0 for OK, non-0 for failure.
@@ skipping 262 matching lines @@
 }
 
 TEST_F(RtcpReceiverTest, GetRtt) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
   // No report block received.
-  EXPECT_EQ(
-      -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   rtcp::ReportBlock rb;
   rb.To(kSourceSsrc);
   rtcp::ReceiverReport rr;
   rr.From(kSenderSsrc);
   rr.WithReportBlock(rb);
   rtc::scoped_ptr<rtcp::RawPacket> packet(rr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
-  EXPECT_EQ(
-      0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
 
   // Report block not received.
-  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr,
-                                    nullptr));
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
   rtcp::Ij ij;
   rtc::scoped_ptr<rtcp::RawPacket> packet(ij.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
   EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) {
@@ skipping 191 matching lines @@
 
   const uint8_t kLossRate = 123;
   rtcp::VoipMetric voip_metric;
   voip_metric.To(kSourceSsrc);
   voip_metric.LossRate(kLossRate);
   rtcp::Xr xr;
   xr.From(0x2345);
   xr.WithVoipMetric(&voip_metric);
   rtc::scoped_ptr<rtcp::RawPacket> packet(xr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr);
+  ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL);
   EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
   EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
 }
 
 TEST_F(RtcpReceiverTest, XrVoipPacketNotToUsIgnored) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kSourceSsrc);
   rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
 
@@ skipping 233 matching lines @@
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   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(-1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 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.To(kMediaFlowSsrc);
   tmmbr.WithBitrateKbps(30);
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
 
-  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   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));
 }
 
 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
   const uint32_t kMediaFlowSsrc = 0x2040608;
   const uint32_t kSenderSsrc = 0x10203;
 
   rtcp::Tmmbr tmmbr;
   tmmbr.From(kSenderSsrc);
   tmmbr.To(kMediaFlowSsrc + 1);  // This SSRC is not what we are sending.
   tmmbr.WithBitrateKbps(30);
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
 
   std::set<uint32_t> ssrcs;
   ssrcs.insert(kMediaFlowSsrc);
   rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 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.To(kMediaFlowSsrc);
   tmmbr.WithBitrateKbps(0);
 
   rtcp::SenderReport sr;
   sr.From(kSenderSsrc);
   sr.Append(&tmmbr);
   rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
 
   EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
-  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
 }
 
 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.To(kMediaFlowSsrc);
     tmmbr.WithBitrateKbps(30);
 
     rtcp::SenderReport sr;
     sr.From(ssrc);
     sr.Append(&tmmbr);
     rtc::scoped_ptr<rtcp::RawPacket> packet(sr.Build());
     EXPECT_EQ(0, InjectRtcpPacket(packet->Buffer(), packet->Length()));
     // 5 seconds between each packet.
     system_clock_.AdvanceTimeMilliseconds(5000);
   }
   // It is now starttime + 15.
-  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr));
+  EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   TMMBRSet candidate_set;
   candidate_set.VerifyAndAllocateSet(3);
   EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
   EXPECT_LT(0U, candidate_set.Tmmbr(0));
   // 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(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
   EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
   EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
 }
 
 TEST_F(RtcpReceiverTest, Callbacks) {
   class RtcpCallbackImpl : public RtcpStatisticsCallback {
    public:
     RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {}
     virtual ~RtcpCallbackImpl() {}
 
@@ skipping 40 matching lines @@
   rb1.WithJitter(kJitter);
 
   rtcp::ReceiverReport rr1;
   rr1.From(kSenderSsrc);
   rr1.WithReportBlock(rb1);
   rtc::scoped_ptr<rtcp::RawPacket> p1(rr1.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p1->Buffer(), p1->Length()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 
-  rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr);
+  rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL);
 
   // Add arbitrary numbers, callback should not be called (retain old values).
   rtcp::ReportBlock rb2;
   rb2.To(kSourceSsrc);
   rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
   rb2.WithFractionLost(42);
   rb2.WithCumulativeLost(137);
   rb2.WithJitter(4711);
 
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc);
   rr2.WithReportBlock(rb2);
   rtc::scoped_ptr<rtcp::RawPacket> p2(rr2.Build());
   EXPECT_EQ(0, InjectRtcpPacket(p2->Buffer(), p2->Length()));
   EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
                                kCumulativeLoss, kJitter));
 }
 
 }  // Anonymous namespace
 
 }  // namespace webrtc