Revert of Wire up send-side bandwidth estimation.

webrtc/video/rampup_tests.cc

 /*
  *  Copyright (c) 2013 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 "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
-#include "webrtc/base/event.h"
-#include "webrtc/modules/pacing/include/packet_router.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
-#include "webrtc/system_wrappers/interface/thread_wrapper.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/rampup_tests.h"
 
 namespace webrtc {
 namespace {
 
 static const int kMaxPacketSize = 1500;
 const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
 
 std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
@@ skipping 31 matching lines @@
   // RtpHeaderParser and a RemoteBitrateEstimator here, but due to the current
   // state of the RTP module we need a full module and receive statistics to
   // be able to produce an RTCP with REMB.
   RtpRtcp::Configuration config;
   config.receive_statistics = receive_stats_.get();
   feedback_transport_.Enable();
   config.outgoing_transport = &feedback_transport_;
   rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
   rtp_rtcp_->SetREMBStatus(true);
   rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
-  packet_router_.reset(new PacketRouter());
-  packet_router_->AddRtpModule(rtp_rtcp_.get());
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                           kAbsSendTimeExtensionId);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
                                           kTransmissionTimeOffsetExtensionId);
-  rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
-                                          kTransportSequenceNumberExtensionId);
   payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType,
                                        RampUpTest::kFakeSendPayloadType);
 }
 
-StreamObserver::~StreamObserver() {
-  packet_router_->RemoveRtpModule(rtp_rtcp_.get());
-}
-
 void StreamObserver::set_expected_bitrate_bps(
     unsigned int expected_bitrate_bps) {
   rtc::CritScope lock(&crit_);
   expected_bitrate_bps_ = expected_bitrate_bps;
 }
 
 void StreamObserver::set_start_bitrate_bps(unsigned int start_bitrate_bps) {
   rtc::CritScope lock(&crit_);
   start_bitrate_bps_ = start_bitrate_bps;
 }
@@ skipping 65 matching lines @@
 }
 
 EventTypeWrapper StreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
 void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) {
   remote_bitrate_estimator_.reset(rbe);
 }
 
-PacketRouter* StreamObserver::GetPacketRouter() {
-  return packet_router_.get();
-}
-
 void StreamObserver::ReportResult(const std::string& measurement,
                   size_t value,
                   const std::string& units) {
   webrtc::test::PrintResult(
       measurement, "",
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       value, units, false);
 }
 
 void StreamObserver::TriggerTestDone() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
@@ skipping 188 matching lines @@
       }
       break;
     }
   }
 }
 
 EventTypeWrapper LowRateStreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
-class SendBitrateAdapter {
- public:
-  static const int64_t kPollIntervalMs = 250;
-
-  SendBitrateAdapter(const Call& call,
-                     const std::vector<uint32_t>& ssrcs,
-                     RemoteBitrateObserver* bitrate_observer)
-      : event_(false, false),
-        call_(call),
-        ssrcs_(ssrcs),
-        bitrate_observer_(bitrate_observer) {
-    RTC_DCHECK(bitrate_observer != nullptr);
-    poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread,
-                                                 this, "SendBitratePoller");
-    RTC_DCHECK(poller_thread_->Start());
-  }
-
-  virtual ~SendBitrateAdapter() {
-    event_.Set();
-    poller_thread_->Stop();
-  }
-
- private:
-  static bool SendBitrateAdapterThread(void* obj) {
-    return static_cast<SendBitrateAdapter*>(obj)->PollStats();
-  }
-
-  bool PollStats() {
-    Call::Stats stats = call_.GetStats();
-
-    bitrate_observer_->OnReceiveBitrateChanged(ssrcs_,
-                                               stats.send_bandwidth_bps);
-    return !event_.Wait(kPollIntervalMs);
-  }
-
-  rtc::Event event_;
-  rtc::scoped_ptr<ThreadWrapper> poller_thread_;
-  const Call& call_;
-  const std::vector<uint32_t> ssrcs_;
-  RemoteBitrateObserver* const bitrate_observer_;
-};
-
 void RampUpTest::RunRampUpTest(size_t num_streams,
                                unsigned int start_bitrate_bps,
                                const std::string& extension_type,
                                bool rtx,
                                bool red) {
   std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100));
   std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200));
   StreamObserver::SsrcMap rtx_ssrc_map;
   if (rtx) {
     for (size_t i = 0; i < ssrcs.size(); ++i)
       rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i];
   }
 
   test::DirectTransport receiver_transport;
   StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport,
                                  Clock::GetRealTimeClock());
 
   CreateSendConfig(num_streams, &stream_observer);
   send_config_.rtp.extensions.clear();
 
-  rtc::scoped_ptr<SendBitrateAdapter> send_bitrate_adapter_;
-
   if (extension_type == RtpExtension::kAbsSendTime) {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorAbsSendTime(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kAbsSendTimeExtensionId));
-  } else if (extension_type == RtpExtension::kTransportSequenceNumber) {
-    stream_observer.SetRemoteBitrateEstimator(new RemoteEstimatorProxy(
-        Clock::GetRealTimeClock(), stream_observer.GetPacketRouter()));
-    send_config_.rtp.extensions.push_back(RtpExtension(
-        extension_type.c_str(), kTransportSequenceNumberExtensionId));
   } else {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorSingleStream(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
   }
 
   Call::Config call_config;
@@ skipping 31 matching lines @@
     int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
     for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
       expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
     }
     stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
   }
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
-  if (extension_type == RtpExtension::kTransportSequenceNumber) {
-    send_bitrate_adapter_.reset(
-        new SendBitrateAdapter(*sender_call_.get(), ssrcs, &stream_observer));
-  }
   Start();
 
   EXPECT_EQ(kEventSignaled, stream_observer.Wait());
 
-  // Destroy the SendBitrateAdapter (if any) to stop the poller thread in it,
-  // otherwise we might get a data race with the destruction of the call.
-  send_bitrate_adapter_.reset();
-
   Stop();
   DestroyStreams();
 }
 
 void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams,
                                      bool rtx,
                                      bool red) {
   test::DirectTransport receiver_transport;
   LowRateStreamObserver stream_observer(
       &receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx);
@@ skipping 90 matching lines @@
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
   RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, true, true);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
   RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
                 false, false);
 }
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
-  RunRampUpTest(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
-  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
-}
-
-TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
-  RunRampUpTest(1, 0.9 * kSingleStreamTargetBps,
-                RtpExtension::kTransportSequenceNumber, false, false);
-}
 }  // namespace webrtc