Removed old probe cluster logic and logic related to ssrcs from DelayBasedBwe.

webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.cc

 /*
  *  Copyright (c) 2016 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 "webrtc/modules/congestion_controller/delay_based_bwe_unittest_helper.h"
@@ skipping 150 matching lines @@
   stream_generator_->AddStream(new test::RtpStream(30, 3e5));
 }
 
 const uint32_t DelayBasedBweTest::kDefaultSsrc = 0;
 
 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
                                          int64_t send_time_ms,
                                          uint16_t sequence_number,
                                          size_t payload_size) {
   IncomingFeedback(arrival_time_ms, send_time_ms, sequence_number, payload_size,
-                   0);
+                   PacketInfo::kNotAProbe);

[stefan-webrtc, 2016/08/11 11:43:18]

Why do we classify these as not being probes now?

[philipel, 2016/08/11 13:30:51]

It didn't make sense to let this function always insert a packet info saying
this is a probe as all other functions (*TestHelper) using this function in a
loop would result in huge clusters being inserted.

 }
 
 void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms,
                                          int64_t send_time_ms,
                                          uint16_t sequence_number,
                                          size_t payload_size,
                                          int probe_cluster_id) {
   RTC_CHECK_GE(arrival_time_ms + arrival_time_offset_ms_, 0);
   PacketInfo packet(arrival_time_ms + arrival_time_offset_ms_, send_time_ms,
                     sequence_number, payload_size, probe_cluster_id);
@@ skipping 86 matching lines @@
   clock_.AdvanceTimeMilliseconds(1000);
   // Inserting packets for 5 seconds to get a valid estimate.
   for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) {
     if (i == kNumInitialPackets) {
       bitrate_estimator_->Process();
       EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
       EXPECT_EQ(0u, ssrcs.size());
       EXPECT_FALSE(bitrate_observer_->updated());
       bitrate_observer_->Reset();
     }
-
+    int cluster_id = i < 5 ? 0 : PacketInfo::kNotAProbe;

[stefan-webrtc, 2016/08/11 11:43:18]

What does 5 mean?

[philipel, 2016/08/11 13:30:51]

Since I changed the behavior of IncomingFeeback/4 to not always insert a probe I
now let the first 5 packets be probing packets.

[stefan-webrtc, 2016/08/11 15:38:59]

Does it work I'd you dont pass in probe packets? If not, at least make 5 a
constant.

[philipel, 2016/08/12 08:31:02]

This test check that the expected bitrate converges after a certain amount of
time, and if we don't start off by probing then it wont have enough time to
converge.

Earlier the first packets were considered to be probing packets, now we have to
specify that explicitly.

Changed to a constant.

     IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms,
-                     sequence_number++, kMtu);
+                     sequence_number++, kMtu, cluster_id);
     clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
     send_time_ms += kFrameIntervalMs;
   }
   bitrate_estimator_->Process();
   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
   ASSERT_EQ(1u, ssrcs.size());
   EXPECT_EQ(kDefaultSsrc, ssrcs.front());
   EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps);
   EXPECT_TRUE(bitrate_observer_->updated());
   bitrate_observer_->Reset();
   EXPECT_EQ(bitrate_observer_->latest_bitrate(), bitrate_bps);
-  bitrate_estimator_->RemoveStream(kDefaultSsrc);
-  EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
-  ASSERT_EQ(0u, ssrcs.size());
-  EXPECT_EQ(0u, bitrate_bps);
 }
 
 void DelayBasedBweTest::RateIncreaseReorderingTestHelper(
     uint32_t expected_bitrate_bps) {
   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
   const int kFrameIntervalMs = 1000 / kFramerate;
   int64_t send_time_ms = 0;
   uint16_t sequence_number = 0;
   // Inserting packets for five seconds to get a valid estimate.
   for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) {
     // TODO(sprang): Remove this hack once the single stream estimator is gone,
     // as it doesn't do anything in Process().
     if (i == kNumInitialPackets) {
       // Process after we have enough frames to get a valid input rate estimate.
       bitrate_estimator_->Process();
       EXPECT_FALSE(bitrate_observer_->updated());  // No valid estimate.
     }
-
+    int cluster_id = i < 5 ? 0 : PacketInfo::kNotAProbe;
     IncomingFeedback(clock_.TimeInMilliseconds(), send_time_ms,
-                     sequence_number++, kMtu);
+                     sequence_number++, kMtu, cluster_id);
     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
     send_time_ms += kFrameIntervalMs;
   }
   bitrate_estimator_->Process();
   EXPECT_TRUE(bitrate_observer_->updated());
   EXPECT_NEAR(expected_bitrate_bps, bitrate_observer_->latest_bitrate(),
               kAcceptedBitrateErrorBps);
   for (int i = 0; i < 10; ++i) {
     clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
     send_time_ms += 2 * kFrameIntervalMs;
@@ skipping 165 matching lines @@
                      sequence_number++, 1000);
     clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
     send_time_ms += kFrameIntervalMs;
     bitrate_estimator_->Process();
   }
   uint32_t bitrate_after = 0;
   bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_after);
   EXPECT_LT(bitrate_after, bitrate_before);
 }
 }  // namespace webrtc