1 files changed, 0 insertions, 224 deletions
diff --git a/chromium/net/quic/congestion_control/channel_estimator_test.cc b/chromium/net/quic/congestion_control/channel_estimator_test.cc
deleted file mode 100644
index 460e436589e..00000000000
--- a/chromium/net/quic/congestion_control/channel_estimator_test.cc
+++ /dev/null
@@ -1,224 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/logging.h"
-#include "net/quic/congestion_control/channel_estimator.h"
-#include "net/quic/test_tools/mock_clock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace net {
-namespace test {
-
-class ChannelEstimatorTest : public ::testing::Test {
- protected:
-  virtual void SetUp() {
-    srand(1234);
-    packet_size_ = 1200;
-    sequence_number_ = 1;
-  }
-
-  QuicPacketSequenceNumber sequence_number_;
-  QuicByteCount packet_size_;
-  MockClock send_clock_;
-  MockClock receive_clock_;
-  ChannelEstimator channel_estimator_;
-};
-
-TEST_F(ChannelEstimatorTest, SimpleNonDetect) {
-  // In this test, the send times differ by the same delta as the receive times,
-  // so we haven't sent packets closely enough to detect "spreading," or
-  // effective bandwidth.
-  QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10);
-
-  for (int i = 0; i < 1000; ++i) {
-    QuicTime send_time = send_clock_.ApproximateNow();
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(delta);
-    receive_clock_.AdvanceTime(delta);
-  }
-  QuicBandwidth estimate = QuicBandwidth::Zero();
-  EXPECT_EQ(kChannelEstimateUnknown,
-            channel_estimator_.GetChannelEstimate(&estimate));
-  EXPECT_TRUE(estimate.IsZero());
-}
-
-TEST_F(ChannelEstimatorTest, SimplePacketPairDetect) {
-  // In this test, we start by sending packet pairs back-to-back and
-  // add a receive side spreading that indicate an effective bandwidth.
-  // We do 2 testes with different effective bandwidth to make sure that we
-  // detect the new effective bandwidth.
-  QuicTime::Delta received_delta = QuicTime::Delta::FromMilliseconds(5);
-  QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10);
-
-  for (int i = 0; i < 100; ++i) {
-    receive_clock_.AdvanceTime(received_delta);
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    QuicTime send_time = send_clock_.ApproximateNow();
-
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    receive_clock_.AdvanceTime(received_delta);
-    receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(send_delta);
-  }
-  QuicBandwidth estimate = QuicBandwidth::Zero();
-  EXPECT_EQ(kChannelEstimateGood,
-            channel_estimator_.GetChannelEstimate(&estimate));
-  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta),
-            estimate);
-  received_delta = QuicTime::Delta::FromMilliseconds(1);
-  for (int i = 0; i < 100; ++i) {
-    receive_clock_.AdvanceTime(received_delta);
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    QuicTime send_time = send_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    receive_clock_.AdvanceTime(received_delta);
-    receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(send_delta);
-  }
-  EXPECT_EQ(kChannelEstimateGood,
-            channel_estimator_.GetChannelEstimate(&estimate));
-  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta),
-            estimate);
-}
-
-TEST_F(ChannelEstimatorTest, SimpleFlatSlope) {
-  // In this test, we send packet pairs back-to-back and add a slowly increasing
-  // receive side spreading. We expect the estimate to be good and that our
-  // mean receive side spreading is returned as the estimate.
-  QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5);
-  QuicTime::Delta received_delta = initial_received_delta;
-  QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10);
-
-  for (int i = 0; i < 100; ++i) {
-    receive_clock_.AdvanceTime(received_delta);
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    QuicTime send_time = send_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    receive_clock_.AdvanceTime(received_delta);
-    receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(send_delta);
-    received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(10));
-  }
-  QuicBandwidth estimate = QuicBandwidth::Zero();
-  EXPECT_EQ(kChannelEstimateGood,
-            channel_estimator_.GetChannelEstimate(&estimate));
-
-  // Calculate our mean receive delta.
-  QuicTime::Delta increased_received_delta =
-      received_delta.Subtract(initial_received_delta);
-  QuicTime::Delta mean_received_delta = initial_received_delta.Add(
-      QuicTime::Delta::FromMicroseconds(
-          increased_received_delta.ToMicroseconds() / 2));
-
-  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_,
-      mean_received_delta), estimate);
-}
-
-TEST_F(ChannelEstimatorTest, SimpleMediumSlope) {
-  // In this test, we send packet pairs back-to-back and add an increasing
-  // receive side spreading. We expect the estimate to be uncertaint and that
-  // our mean receive side spreading is returned as the estimate.
-  QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5);
-  QuicTime::Delta received_delta = initial_received_delta;
-  QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10);
-
-  for (int i = 0; i < 100; ++i) {
-    receive_clock_.AdvanceTime(received_delta);
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    QuicTime send_time = send_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    receive_clock_.AdvanceTime(received_delta);
-    receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(send_delta);
-    received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(50));
-  }
-  QuicBandwidth estimate = QuicBandwidth::Zero();
-  EXPECT_EQ(kChannelEstimateUncertain,
-            channel_estimator_.GetChannelEstimate(&estimate));
-
-  // Calculate our mean receive delta.
-  QuicTime::Delta increased_received_delta =
-      received_delta.Subtract(initial_received_delta);
-  QuicTime::Delta mean_received_delta = initial_received_delta.Add(
-      QuicTime::Delta::FromMicroseconds(
-          increased_received_delta.ToMicroseconds() / 2));
-
-  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_,
-      mean_received_delta), estimate);
-}
-
-TEST_F(ChannelEstimatorTest, SimpleSteepSlope) {
-  // In this test, we send packet pairs back-to-back and add a rapidly
-  // increasing receive side spreading. We expect the estimate to be uncertain
-  // and that our mean receive side spreading is returned as the estimate.
-  QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5);
-  QuicTime::Delta received_delta = initial_received_delta;
-  QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10);
-
-  for (int i = 0; i < 100; ++i) {
-    receive_clock_.AdvanceTime(received_delta);
-    QuicTime receive_time = receive_clock_.ApproximateNow();
-    QuicTime send_time = send_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    receive_clock_.AdvanceTime(received_delta);
-    receive_time = receive_clock_.ApproximateNow();
-    channel_estimator_.OnAcknowledgedPacket(sequence_number_++,
-                                            packet_size_,
-                                            send_time,
-                                            receive_time);
-    send_clock_.AdvanceTime(send_delta);
-    received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(100));
-  }
-  QuicBandwidth estimate = QuicBandwidth::Zero();
-  EXPECT_EQ(kChannelEstimateUncertain,
-            channel_estimator_.GetChannelEstimate(&estimate));
-
-  // Calculate our mean receive delta.
-  QuicTime::Delta increased_received_delta =
-      received_delta.Subtract(initial_received_delta);
-  QuicTime::Delta mean_received_delta = initial_received_delta.Add(
-      QuicTime::Delta::FromMicroseconds(
-          increased_received_delta.ToMicroseconds() / 2));
-
-  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_,
-      mean_received_delta), estimate);
-}
-
-}  // namespace test
-}  // namespace net