Update from https://crrev.com/303153
This updates from chromium https://crrev.com/303153 aka
f9567f85788355bf3da8df030cbc232421d00b7d with the following additional
changes:
Update skia_build.patch and cc_strip_video.patch with trivial changes.
Update gpu::CommandBuffer state serialization for upstream changes.
Update ui/compositor/layer for upstream cc::SurfaceLayer changes.
TBR=jam@chromium.org
Review URL: https://codereview.chromium.org/706203003
diff --git a/net/quic/congestion_control/rtt_stats.cc b/net/quic/congestion_control/rtt_stats.cc
index 7b25b6c..dfb50ef 100644
--- a/net/quic/congestion_control/rtt_stats.cc
+++ b/net/quic/congestion_control/rtt_stats.cc
@@ -32,10 +32,6 @@
num_min_rtt_samples_remaining_(0),
recent_min_rtt_window_(QuicTime::Delta::Infinite()) {}
-bool RttStats::HasUpdates() const {
- return !smoothed_rtt_.IsZero();
-}
-
void RttStats::SampleNewRecentMinRtt(uint32 num_samples) {
num_min_rtt_samples_remaining_ = num_samples;
new_min_rtt_ = RttSample();
@@ -78,7 +74,7 @@
}
latest_rtt_ = rtt_sample;
// First time call.
- if (!HasUpdates()) {
+ if (smoothed_rtt_.IsZero()) {
smoothed_rtt_ = rtt_sample;
mean_deviation_ = QuicTime::Delta::FromMicroseconds(
rtt_sample.ToMicroseconds() / 2);
@@ -131,18 +127,4 @@
}
}
-QuicTime::Delta RttStats::SmoothedRtt() const {
- if (!HasUpdates()) {
- return QuicTime::Delta::FromMicroseconds(initial_rtt_us_);
- }
- return smoothed_rtt_;
-}
-
-QuicTime::Delta RttStats::MinRtt() const {
- if (!HasUpdates()) {
- return QuicTime::Delta::FromMicroseconds(initial_rtt_us_);
- }
- return min_rtt_;
-}
-
} // namespace net
diff --git a/net/quic/congestion_control/rtt_stats.h b/net/quic/congestion_control/rtt_stats.h
index b7ec6b9..9dd5620 100644
--- a/net/quic/congestion_control/rtt_stats.h
+++ b/net/quic/congestion_control/rtt_stats.h
@@ -41,12 +41,11 @@
// |num_samples| UpdateRtt calls.
void SampleNewRecentMinRtt(uint32 num_samples);
- QuicTime::Delta SmoothedRtt() const;
-
- // Returns the min_rtt for the entire connection if a min has been measured.
- // This returns an initial non-zero RTT estimate if no measurements have yet
- // been made.
- QuicTime::Delta MinRtt() const;
+ // Returns the EWMA smoothed RTT for the connection.
+ // May return Zero if no valid updates have occurred.
+ QuicTime::Delta smoothed_rtt() const {
+ return smoothed_rtt_;
+ }
int64 initial_rtt_us() const {
return initial_rtt_us_;
@@ -57,10 +56,18 @@
initial_rtt_us_ = initial_rtt_us;
}
+ // The most recent rtt measurement.
+ // May return Zero if no valid updates have occurred.
QuicTime::Delta latest_rtt() const {
return latest_rtt_;
}
+ // Returns the min_rtt for the entire connection.
+ // May return Zero if no valid updates have occurred.
+ QuicTime::Delta min_rtt() const {
+ return min_rtt_;
+ }
+
// Returns the min_rtt since SampleNewRecentMinRtt has been called, or the
// min_rtt for the entire connection if SampleNewMinRtt was never called.
QuicTime::Delta recent_min_rtt() const {
diff --git a/net/quic/congestion_control/rtt_stats_test.cc b/net/quic/congestion_control/rtt_stats_test.cc
index d3a683e..6aaf2a6 100644
--- a/net/quic/congestion_control/rtt_stats_test.cc
+++ b/net/quic/congestion_control/rtt_stats_test.cc
@@ -37,10 +37,8 @@
TEST_F(RttStatsTest, DefaultsBeforeUpdate) {
EXPECT_LT(0u, rtt_stats_.initial_rtt_us());
- EXPECT_EQ(QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us()),
- rtt_stats_.MinRtt());
- EXPECT_EQ(QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us()),
- rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.min_rtt());
+ EXPECT_EQ(QuicTime::Delta::Zero(), rtt_stats_.smoothed_rtt());
}
TEST_F(RttStatsTest, SmoothedRtt) {
@@ -49,58 +47,58 @@
QuicTime::Delta::FromMilliseconds(100),
QuicTime::Zero());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.smoothed_rtt());
// Verify that effective RTT of zero does not change Smoothed RTT.
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
QuicTime::Delta::FromMilliseconds(200),
QuicTime::Zero());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.smoothed_rtt());
// Verify that large erroneous ack_delay does not change Smoothed RTT.
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
QuicTime::Delta::FromMilliseconds(300),
QuicTime::Zero());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.latest_rtt());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.smoothed_rtt());
}
TEST_F(RttStatsTest, MinRtt) {
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(200),
QuicTime::Delta::Zero(),
QuicTime::Zero());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
rtt_stats_.recent_min_rtt());
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(10),
QuicTime::Delta::Zero(),
QuicTime::Zero().Add(
QuicTime::Delta::FromMilliseconds(10)));
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
QuicTime::Delta::Zero(),
QuicTime::Zero().Add(
QuicTime::Delta::FromMilliseconds(20)));
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
QuicTime::Delta::Zero(),
QuicTime::Zero().Add(
QuicTime::Delta::FromMilliseconds(30)));
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
QuicTime::Delta::Zero(),
QuicTime::Zero().Add(
QuicTime::Delta::FromMilliseconds(40)));
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
// Verify that ack_delay does not go into recording of min_rtt_.
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(7),
QuicTime::Delta::FromMilliseconds(2),
QuicTime::Zero().Add(
QuicTime::Delta::FromMilliseconds(50)));
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(7), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(7), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(7), rtt_stats_.recent_min_rtt());
}
@@ -108,7 +106,7 @@
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(10),
QuicTime::Delta::Zero(),
QuicTime::Zero());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
rtt_stats_.SampleNewRecentMinRtt(4);
@@ -116,14 +114,14 @@
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
QuicTime::Delta::Zero(),
QuicTime::Zero());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10),
rtt_stats_.recent_min_rtt());
}
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(50),
QuicTime::Delta::Zero(),
QuicTime::Zero());
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(50), rtt_stats_.recent_min_rtt());
}
@@ -134,7 +132,7 @@
QuicTime now = QuicTime::Zero();
QuicTime::Delta rtt_sample = QuicTime::Delta::FromMilliseconds(10);
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.recent_min_rtt());
// Gradually increase the rtt samples and ensure the recent_min_rtt starts
@@ -143,7 +141,7 @@
now = now.Add(QuicTime::Delta::FromMilliseconds(25));
rtt_sample = rtt_sample.Add(QuicTime::Delta::FromMilliseconds(10));
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(rtt_sample, RttStatsPeer::GetQuarterWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample.Subtract(QuicTime::Delta::FromMilliseconds(10)),
RttStatsPeer::GetHalfWindowRtt(&rtt_stats_));
@@ -165,7 +163,7 @@
// A new quarter rtt low sets that, but nothing else.
rtt_sample = rtt_sample.Subtract(QuicTime::Delta::FromMilliseconds(5));
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(rtt_sample, RttStatsPeer::GetQuarterWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample.Subtract(QuicTime::Delta::FromMilliseconds(5)),
RttStatsPeer::GetHalfWindowRtt(&rtt_stats_));
@@ -175,7 +173,7 @@
// A new half rtt low sets that and the quarter rtt low.
rtt_sample = rtt_sample.Subtract(QuicTime::Delta::FromMilliseconds(15));
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(rtt_sample, RttStatsPeer::GetQuarterWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample, RttStatsPeer::GetHalfWindowRtt(&rtt_stats_));
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(70),
@@ -184,7 +182,7 @@
// A new full window loss sets the recent_min_rtt, but not min_rtt.
rtt_sample = QuicTime::Delta::FromMilliseconds(65);
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.MinRtt());
+ EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), rtt_stats_.min_rtt());
EXPECT_EQ(rtt_sample, RttStatsPeer::GetQuarterWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample, RttStatsPeer::GetHalfWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample, rtt_stats_.recent_min_rtt());
@@ -193,7 +191,7 @@
rtt_sample = QuicTime::Delta::FromMilliseconds(5);
rtt_stats_.UpdateRtt(rtt_sample, QuicTime::Delta::Zero(), now);
- EXPECT_EQ(rtt_sample, rtt_stats_.MinRtt());
+ EXPECT_EQ(rtt_sample, rtt_stats_.min_rtt());
EXPECT_EQ(rtt_sample, RttStatsPeer::GetQuarterWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample, RttStatsPeer::GetHalfWindowRtt(&rtt_stats_));
EXPECT_EQ(rtt_sample, rtt_stats_.recent_min_rtt());
@@ -202,27 +200,27 @@
TEST_F(RttStatsTest, ExpireSmoothedMetrics) {
QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(10);
rtt_stats_.UpdateRtt(initial_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
- EXPECT_EQ(initial_rtt, rtt_stats_.MinRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt());
EXPECT_EQ(initial_rtt, rtt_stats_.recent_min_rtt());
- EXPECT_EQ(initial_rtt, rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt());
EXPECT_EQ(initial_rtt.Multiply(0.5), rtt_stats_.mean_deviation());
// Update once with a 20ms RTT.
QuicTime::Delta doubled_rtt = initial_rtt.Multiply(2);
rtt_stats_.UpdateRtt(doubled_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
- EXPECT_EQ(initial_rtt.Multiply(1.125), rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(initial_rtt.Multiply(1.125), rtt_stats_.smoothed_rtt());
// Expire the smoothed metrics, increasing smoothed rtt and mean deviation.
rtt_stats_.ExpireSmoothedMetrics();
- EXPECT_EQ(doubled_rtt, rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(doubled_rtt, rtt_stats_.smoothed_rtt());
EXPECT_EQ(initial_rtt.Multiply(0.875), rtt_stats_.mean_deviation());
// Now go back down to 5ms and expire the smoothed metrics, and ensure the
// mean deviation increases to 15ms.
QuicTime::Delta half_rtt = initial_rtt.Multiply(0.5);
rtt_stats_.UpdateRtt(half_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
- EXPECT_GT(doubled_rtt, rtt_stats_.SmoothedRtt());
+ EXPECT_GT(doubled_rtt, rtt_stats_.smoothed_rtt());
EXPECT_LT(initial_rtt, rtt_stats_.mean_deviation());
}
@@ -232,9 +230,9 @@
QuicTime::Delta initial_rtt = QuicTime::Delta::FromMilliseconds(10);
rtt_stats_.UpdateRtt(initial_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
- EXPECT_EQ(initial_rtt, rtt_stats_.MinRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt());
EXPECT_EQ(initial_rtt, rtt_stats_.recent_min_rtt());
- EXPECT_EQ(initial_rtt, rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt());
vector<QuicTime::Delta> bad_send_deltas;
bad_send_deltas.push_back(QuicTime::Delta::Zero());
@@ -249,9 +247,9 @@
rtt_stats_.UpdateRtt(bad_send_delta,
QuicTime::Delta::Zero(),
QuicTime::Zero());
- EXPECT_EQ(initial_rtt, rtt_stats_.MinRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.min_rtt());
EXPECT_EQ(initial_rtt, rtt_stats_.recent_min_rtt());
- EXPECT_EQ(initial_rtt, rtt_stats_.SmoothedRtt());
+ EXPECT_EQ(initial_rtt, rtt_stats_.smoothed_rtt());
}
}
diff --git a/net/quic/congestion_control/tcp_cubic_sender.cc b/net/quic/congestion_control/tcp_cubic_sender.cc
index 44e4b3e..5f20597 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender.cc
@@ -22,7 +22,6 @@
// fast retransmission. The cwnd after a timeout is still 1.
const QuicPacketCount kMinimumCongestionWindow = 2;
const QuicByteCount kMaxSegmentSize = kDefaultTCPMSS;
-const int64 kInitialCongestionWindow = 10;
const int kMaxBurstLength = 3;
const float kRenoBeta = 0.7f; // Reno backoff factor.
const uint32 kDefaultNumConnections = 2; // N-connection emulation.
@@ -44,7 +43,7 @@
largest_sent_sequence_number_(0),
largest_acked_sequence_number_(0),
largest_sent_at_last_cutback_(0),
- congestion_window_(kInitialCongestionWindow),
+ congestion_window_(kDefaultInitialWindow),
previous_congestion_window_(0),
slowstart_threshold_(max_tcp_congestion_window),
previous_slowstart_threshold_(0),
@@ -63,11 +62,13 @@
// Initial window experiment. Ignore the initial congestion
// window suggested by the client and use the default ICWND of
// 10 instead.
- congestion_window_ = kInitialCongestionWindow;
+ congestion_window_ = kDefaultInitialWindow;
} else if (config.HasReceivedInitialCongestionWindow()) {
// Set the initial window size.
- congestion_window_ = min(kMaxInitialWindow,
- config.ReceivedInitialCongestionWindow());
+ congestion_window_ = max(kMinimumCongestionWindow,
+ min(kMaxInitialWindow,
+ static_cast<QuicPacketCount>(
+ config.ReceivedInitialCongestionWindow())));
}
}
}
@@ -92,7 +93,7 @@
const CongestionVector& lost_packets) {
if (rtt_updated && InSlowStart() &&
hybrid_slow_start_.ShouldExitSlowStart(rtt_stats_->latest_rtt(),
- rtt_stats_->MinRtt(),
+ rtt_stats_->min_rtt(),
congestion_window_)) {
slowstart_threshold_ = congestion_window_;
}
@@ -203,27 +204,34 @@
// We pace at twice the rate of the underlying sender's bandwidth estimate
// during slow start and 1.25x during congestion avoidance to ensure pacing
// doesn't prevent us from filling the window.
- return BandwidthEstimate().Scale(InSlowStart() ? 2 : 1.25);
+ QuicTime::Delta srtt = rtt_stats_->smoothed_rtt();
+ if (srtt.IsZero()) {
+ srtt = QuicTime::Delta::FromMicroseconds(rtt_stats_->initial_rtt_us());
+ }
+ const QuicBandwidth bandwidth =
+ QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(), srtt);
+ return bandwidth.Scale(InSlowStart() ? 2 : 1.25);
}
QuicBandwidth TcpCubicSender::BandwidthEstimate() const {
- if (rtt_stats_->SmoothedRtt().IsZero()) {
- LOG(DFATAL) << "In BandwidthEstimate(), smoothed RTT is zero!";
+ QuicTime::Delta srtt = rtt_stats_->smoothed_rtt();
+ if (srtt.IsZero()) {
+ // If we haven't measured an rtt, the bandwidth estimate is unknown.
return QuicBandwidth::Zero();
}
- return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(),
- rtt_stats_->SmoothedRtt());
+ return QuicBandwidth::FromBytesAndTimeDelta(GetCongestionWindow(), srtt);
}
bool TcpCubicSender::HasReliableBandwidthEstimate() const {
- return !InSlowStart() && !InRecovery();
+ return !InSlowStart() && !InRecovery() &&
+ !rtt_stats_->smoothed_rtt().IsZero();;
}
QuicTime::Delta TcpCubicSender::RetransmissionDelay() const {
- if (!rtt_stats_->HasUpdates()) {
+ if (rtt_stats_->smoothed_rtt().IsZero()) {
return QuicTime::Delta::Zero();
}
- return rtt_stats_->SmoothedRtt().Add(
+ return rtt_stats_->smoothed_rtt().Add(
rtt_stats_->mean_deviation().Multiply(4));
}
@@ -299,7 +307,7 @@
} else {
congestion_window_ = min(max_tcp_congestion_window_,
cubic_.CongestionWindowAfterAck(
- congestion_window_, rtt_stats_->MinRtt()));
+ congestion_window_, rtt_stats_->min_rtt()));
DVLOG(1) << "Cubic; congestion window: " << congestion_window_
<< " slowstart threshold: " << slowstart_threshold_;
}
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 4fe8dbf..48a1300 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -21,8 +21,7 @@
namespace net {
namespace test {
-const int64 kInitialCongestionWindow = 10;
-const uint32 kDefaultWindowTCP = kInitialCongestionWindow * kDefaultTCPMSS;
+const uint32 kDefaultWindowTCP = kDefaultInitialWindow * kDefaultTCPMSS;
const float kRenoBeta = 0.7f; // Reno backoff factor.
// TODO(ianswett): Remove 10000 once b/10075719 is fixed.
@@ -188,6 +187,8 @@
EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
0,
HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
+ EXPECT_EQ(QuicBandwidth::Zero(), sender_->BandwidthEstimate());
// Make sure we can send.
EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
0,
@@ -198,9 +199,12 @@
SendAvailableSendWindow();
AckNPackets(2);
}
- QuicByteCount bytes_to_send = sender_->GetCongestionWindow();
- EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks,
- bytes_to_send);
+ const QuicByteCount cwnd = sender_->GetCongestionWindow();
+ EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks, cwnd);
+ EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
+ EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(
+ cwnd, sender_->rtt_stats_.smoothed_rtt()),
+ sender_->BandwidthEstimate());
}
TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
@@ -301,7 +305,7 @@
TEST_F(TcpCubicSenderTest, NoPRRWhenLessThanOnePacketInFlight) {
SendAvailableSendWindow();
- LoseNPackets(kInitialCongestionWindow - 1);
+ LoseNPackets(kDefaultInitialWindow - 1);
AckNPackets(1);
// PRR will allow 2 packets for every ack during recovery.
EXPECT_EQ(2, SendAvailableSendWindow());
@@ -469,13 +473,13 @@
}
expected_delay = QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs * 4);
- EXPECT_NEAR(kRttMs, sender_->rtt_stats_.SmoothedRtt().ToMilliseconds(), 1);
+ EXPECT_NEAR(kRttMs, sender_->rtt_stats_.smoothed_rtt().ToMilliseconds(), 1);
EXPECT_NEAR(expected_delay.ToMilliseconds(),
sender_->RetransmissionDelay().ToMilliseconds(),
1);
EXPECT_EQ(static_cast<int64>(
sender_->GetCongestionWindow() * kNumMicrosPerSecond /
- sender_->rtt_stats_.SmoothedRtt().ToMicroseconds()),
+ sender_->rtt_stats_.smoothed_rtt().ToMicroseconds()),
sender_->BandwidthEstimate().ToBytesPerSecond());
}
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.cc b/net/quic/congestion_control/tcp_loss_algorithm.cc
index e609122..6cf56d8 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm.cc
@@ -31,7 +31,7 @@
SequenceNumberSet lost_packets;
loss_detection_timeout_ = QuicTime::Zero();
QuicTime::Delta loss_delay =
- rtt_stats.SmoothedRtt().Multiply(kEarlyRetransmitLossDelayMultiplier);
+ rtt_stats.smoothed_rtt().Multiply(kEarlyRetransmitLossDelayMultiplier);
QuicPacketSequenceNumber sequence_number = unacked_packets.GetLeastUnacked();
for (QuicUnackedPacketMap::const_iterator it = unacked_packets.begin();
it != unacked_packets.end() && sequence_number <= largest_observed;
diff --git a/net/quic/congestion_control/tcp_loss_algorithm_test.cc b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
index 34bcc16..5819fb1 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm_test.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
@@ -118,7 +118,7 @@
unacked_packets_.RemoveFromInFlight(2);
unacked_packets_.NackPacket(1, 1);
VerifyLosses(2, nullptr, 0);
- EXPECT_EQ(clock_.Now().Add(rtt_stats_.SmoothedRtt().Multiply(1.25)),
+ EXPECT_EQ(clock_.Now().Add(rtt_stats_.smoothed_rtt().Multiply(1.25)),
loss_algorithm_.GetLossTimeout());
clock_.AdvanceTime(rtt_stats_.latest_rtt().Multiply(1.25));
@@ -133,7 +133,7 @@
SendDataPacket(i);
// Advance the time 1/4 RTT between 3 and 4.
if (i == 3) {
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.25));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
}
}
@@ -148,15 +148,15 @@
VerifyLosses(kNumSentPackets, lost, arraysize(lost));
// The time has already advanced 1/4 an RTT, so ensure the timeout is set
// 1.25 RTTs after the earliest pending packet(3), not the last(4).
- EXPECT_EQ(clock_.Now().Add(rtt_stats_.SmoothedRtt()),
+ EXPECT_EQ(clock_.Now().Add(rtt_stats_.smoothed_rtt()),
loss_algorithm_.GetLossTimeout());
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt());
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
QuicPacketSequenceNumber lost2[] = { 1, 2, 3 };
VerifyLosses(kNumSentPackets, lost2, arraysize(lost2));
- EXPECT_EQ(clock_.Now().Add(rtt_stats_.SmoothedRtt().Multiply(0.25)),
+ EXPECT_EQ(clock_.Now().Add(rtt_stats_.smoothed_rtt().Multiply(0.25)),
loss_algorithm_.GetLossTimeout());
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.25));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
QuicPacketSequenceNumber lost3[] = { 1, 2, 3, 4 };
VerifyLosses(kNumSentPackets, lost3, arraysize(lost3));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
diff --git a/net/quic/congestion_control/time_loss_algorithm.cc b/net/quic/congestion_control/time_loss_algorithm.cc
index 3a7b42d..9dd9ae9 100644
--- a/net/quic/congestion_control/time_loss_algorithm.cc
+++ b/net/quic/congestion_control/time_loss_algorithm.cc
@@ -36,7 +36,7 @@
loss_detection_timeout_ = QuicTime::Zero();
QuicTime::Delta loss_delay = QuicTime::Delta::Max(
QuicTime::Delta::FromMilliseconds(kMinLossDelayMs),
- QuicTime::Delta::Max(rtt_stats.SmoothedRtt(), rtt_stats.latest_rtt())
+ QuicTime::Delta::Max(rtt_stats.smoothed_rtt(), rtt_stats.latest_rtt())
.Multiply(kLossDelayMultiplier));
QuicPacketSequenceNumber sequence_number = unacked_packets.GetLeastUnacked();
diff --git a/net/quic/congestion_control/time_loss_algorithm_test.cc b/net/quic/congestion_control/time_loss_algorithm_test.cc
index 374e563..b964d28 100644
--- a/net/quic/congestion_control/time_loss_algorithm_test.cc
+++ b/net/quic/congestion_control/time_loss_algorithm_test.cc
@@ -60,7 +60,7 @@
unacked_packets_.NackPacket(1, i);
VerifyLosses(2, nullptr, 0);
}
- EXPECT_EQ(rtt_stats_.SmoothedRtt().Multiply(1.25),
+ EXPECT_EQ(rtt_stats_.smoothed_rtt().Multiply(1.25),
loss_algorithm_.GetLossTimeout().Subtract(clock_.Now()));
}
@@ -69,7 +69,7 @@
// Transmit 10 packets at 1/10th an RTT interval.
for (size_t i = 1; i <= kNumSentPackets; ++i) {
SendDataPacket(i);
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.1));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.1));
}
// Expect the timer to not be set.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -78,11 +78,11 @@
unacked_packets_.RemoveFromInFlight(2);
VerifyLosses(2, nullptr, 0);
// Expect the timer to be set to 0.25 RTT's in the future.
- EXPECT_EQ(rtt_stats_.SmoothedRtt().Multiply(0.25),
+ EXPECT_EQ(rtt_stats_.smoothed_rtt().Multiply(0.25),
loss_algorithm_.GetLossTimeout().Subtract(clock_.Now()));
unacked_packets_.NackPacket(1, 5);
VerifyLosses(2, nullptr, 0);
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.25));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
QuicPacketSequenceNumber lost[] = { 1 };
VerifyLosses(2, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -93,7 +93,7 @@
// Transmit 10 packets at 1/10th an RTT interval.
for (size_t i = 1; i <= kNumSentPackets; ++i) {
SendDataPacket(i);
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.1));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.1));
}
// Expect the timer to not be set.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -102,9 +102,9 @@
VerifyLosses(1, nullptr, 0);
// The timer should still not be set.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.25));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
VerifyLosses(1, nullptr, 0);
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt());
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
VerifyLosses(1, nullptr, 0);
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -116,7 +116,7 @@
for (size_t i = 1; i <= kNumSentPackets; ++i) {
SendDataPacket(i);
}
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt());
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
// Expect the timer to not be set.
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
// The packet should not be lost until 1.25 RTTs pass.
@@ -126,9 +126,9 @@
unacked_packets_.RemoveFromInFlight(10);
VerifyLosses(10, nullptr, 0);
// Expect the timer to be set to 0.25 RTT's in the future.
- EXPECT_EQ(rtt_stats_.SmoothedRtt().Multiply(0.25),
+ EXPECT_EQ(rtt_stats_.smoothed_rtt().Multiply(0.25),
loss_algorithm_.GetLossTimeout().Subtract(clock_.Now()));
- clock_.AdvanceTime(rtt_stats_.SmoothedRtt().Multiply(0.25));
+ clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
QuicPacketSequenceNumber lost[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
VerifyLosses(10, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
diff --git a/net/quic/crypto/quic_crypto_server_config.cc b/net/quic/crypto/quic_crypto_server_config.cc
index a5c5d08..5a650b6 100644
--- a/net/quic/crypto/quic_crypto_server_config.cc
+++ b/net/quic/crypto/quic_crypto_server_config.cc
@@ -1420,6 +1420,10 @@
rand, source_address_token.SerializeAsString());
}
+bool QuicCryptoServerConfig::HasProofSource() const {
+ return proof_source_ != nullptr;
+}
+
HandshakeFailureReason QuicCryptoServerConfig::ValidateSourceAddressToken(
const Config& config,
StringPiece token,
diff --git a/net/quic/crypto/quic_crypto_server_config.h b/net/quic/crypto/quic_crypto_server_config.h
index 30e0f6d..dbbff1a 100644
--- a/net/quic/crypto/quic_crypto_server_config.h
+++ b/net/quic/crypto/quic_crypto_server_config.h
@@ -326,6 +326,9 @@
// Set and take ownership of the callback to invoke on primary config changes.
void AcquirePrimaryConfigChangedCb(PrimaryConfigChangedCallback* cb);
+ // Returns true if this config has a |proof_source_|.
+ bool HasProofSource() const;
+
private:
friend class test::QuicCryptoServerConfigPeer;
diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc
index a12b1d0..7c220ad 100644
--- a/net/quic/quic_client_session.cc
+++ b/net/quic/quic_client_session.cc
@@ -155,9 +155,10 @@
TransportSecurityState* transport_security_state,
scoped_ptr<QuicServerInfo> server_info,
const QuicConfig& config,
+ bool is_secure,
base::TaskRunner* task_runner,
NetLog* net_log)
- : QuicClientSessionBase(connection, config),
+ : QuicClientSessionBase(connection, config, is_secure),
require_confirmation_(false),
stream_factory_(stream_factory),
socket_(socket.Pass()),
diff --git a/net/quic/quic_client_session.h b/net/quic/quic_client_session.h
index b1a35d9..6c33eb5 100644
--- a/net/quic/quic_client_session.h
+++ b/net/quic/quic_client_session.h
@@ -96,6 +96,7 @@
TransportSecurityState* transport_security_state,
scoped_ptr<QuicServerInfo> server_info,
const QuicConfig& config,
+ bool is_secure,
base::TaskRunner* task_runner,
NetLog* net_log);
~QuicClientSession() override;
diff --git a/net/quic/quic_client_session_base.cc b/net/quic/quic_client_session_base.cc
index 40d4b86..5b5902b 100644
--- a/net/quic/quic_client_session_base.cc
+++ b/net/quic/quic_client_session_base.cc
@@ -10,8 +10,9 @@
QuicClientSessionBase::QuicClientSessionBase(
QuicConnection* connection,
- const QuicConfig& config)
- : QuicSession(connection, config) {}
+ const QuicConfig& config,
+ bool is_secure)
+ : QuicSession(connection, config, is_secure) {}
QuicClientSessionBase::~QuicClientSessionBase() {}
diff --git a/net/quic/quic_client_session_base.h b/net/quic/quic_client_session_base.h
index d72996c..a7f64fb 100644
--- a/net/quic/quic_client_session_base.h
+++ b/net/quic/quic_client_session_base.h
@@ -14,7 +14,8 @@
class NET_EXPORT_PRIVATE QuicClientSessionBase : public QuicSession {
public:
QuicClientSessionBase(QuicConnection* connection,
- const QuicConfig& config);
+ const QuicConfig& config,
+ bool is_secure);
~QuicClientSessionBase() override;
diff --git a/net/quic/quic_client_session_test.cc b/net/quic/quic_client_session_test.cc
index cae2220..8860f2e 100644
--- a/net/quic/quic_client_session_test.cc
+++ b/net/quic/quic_client_session_test.cc
@@ -46,11 +46,13 @@
session_(connection_, GetSocket().Pass(), nullptr,
&transport_security_state_,
make_scoped_ptr((QuicServerInfo*)nullptr), DefaultQuicConfig(),
+ /*is_secure=*/false,
base::MessageLoop::current()->message_loop_proxy().get(),
&net_log_) {
- session_.InitializeSession(QuicServerId(kServerHostname, kServerPort, false,
+ session_.InitializeSession(QuicServerId(kServerHostname, kServerPort,
+ /*is_secure=*/false,
PRIVACY_MODE_DISABLED),
- &crypto_config_, nullptr);
+ &crypto_config_, nullptr);
}
void TearDown() override { session_.CloseSessionOnError(ERR_ABORTED); }
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 21ea41a..6308d88 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -1139,13 +1139,11 @@
const QuicConnectionStats& QuicConnection::GetStats() {
// Update rtt and estimated bandwidth.
stats_.min_rtt_us =
- sent_packet_manager_.GetRttStats()->MinRtt().ToMicroseconds();
+ sent_packet_manager_.GetRttStats()->min_rtt().ToMicroseconds();
stats_.srtt_us =
- sent_packet_manager_.GetRttStats()->SmoothedRtt().ToMicroseconds();
+ sent_packet_manager_.GetRttStats()->smoothed_rtt().ToMicroseconds();
stats_.estimated_bandwidth =
sent_packet_manager_.BandwidthEstimate().ToBytesPerSecond();
- stats_.congestion_window = sent_packet_manager_.GetCongestionWindow();
- stats_.slow_start_threshold = sent_packet_manager_.GetSlowStartThreshold();
stats_.max_packet_size = packet_generator_.max_packet_length();
return stats_;
}
@@ -1276,7 +1274,7 @@
if (is_server_ && encryption_level_ == ENCRYPTION_NONE &&
last_size_ > packet_generator_.max_packet_length()) {
- packet_generator_.set_max_packet_length(last_size_);
+ set_max_packet_length(last_size_);
}
return true;
}
@@ -1496,7 +1494,7 @@
// perhaps via the NetworkChangeVisitor.
packet_generator_.UpdateSequenceNumberLength(
sent_packet_manager_.least_packet_awaited_by_peer(),
- sent_packet_manager_.GetCongestionWindow());
+ sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
bool reset_retransmission_alarm = sent_packet_manager_.OnPacketSent(
&packet->serialized_packet,
@@ -1586,7 +1584,7 @@
void QuicConnection::OnCongestionWindowChange() {
packet_generator_.OnCongestionWindowChange(
- sent_packet_manager_.GetCongestionWindow());
+ sent_packet_manager_.EstimateMaxPacketsInFlight(max_packet_length()));
visitor_->OnCongestionWindowChange(clock_->ApproximateNow());
}
@@ -1686,7 +1684,8 @@
// 3 times the current congestion window (in slow start) should cover
// about two full round trips worth of packets, which should be
// sufficient.
- 3 * sent_packet_manager_.GetCongestionWindow() / max_packet_length();
+ 3 * sent_packet_manager_.EstimateMaxPacketsInFlight(
+ max_packet_length());
}
}
@@ -1940,11 +1939,7 @@
if (timeout < idle_network_timeout_) {
idle_network_timeout_ = timeout;
- if (FLAGS_quic_timeouts_only_from_alarms) {
- SetTimeoutAlarm();
- } else {
- CheckForTimeout();
- }
+ SetTimeoutAlarm();
} else {
idle_network_timeout_ = timeout;
}
@@ -1953,11 +1948,7 @@
void QuicConnection::SetOverallConnectionTimeout(QuicTime::Delta timeout) {
if (timeout < overall_connection_timeout_) {
overall_connection_timeout_ = timeout;
- if (FLAGS_quic_timeouts_only_from_alarms) {
- SetTimeoutAlarm();
- } else {
- CheckForTimeout();
- }
+ SetTimeoutAlarm();
} else {
overall_connection_timeout_ = timeout;
}
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 7a9e55d..f9f8733 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -431,14 +431,11 @@
void SetIdleNetworkTimeout(QuicTime::Delta timeout);
// Sets (or resets) the total time delta the connection can be alive for.
- // Also, checks and times out the connection if timer has expired for
- // |timeout|. Used to limit the time a connection can be alive before crypto
- // handshake finishes.
+ // Used to limit the time a connection can be alive before crypto handshake
+ // finishes.
void SetOverallConnectionTimeout(QuicTime::Delta timeout);
// Sets the overall and idle state connection timeouts.
- // Times out the connection if the timeout has been reached and
- // the quic_timeouts_only_from_alarms flag is false.
void SetNetworkTimeouts(QuicTime::Delta overall_timeout,
QuicTime::Delta idle_timeout);
diff --git a/net/quic/quic_connection_stats.cc b/net/quic/quic_connection_stats.cc
index 7081d0d..6625c61 100644
--- a/net/quic/quic_connection_stats.cc
+++ b/net/quic/quic_connection_stats.cc
@@ -34,8 +34,6 @@
srtt_us(0),
max_packet_size(0),
estimated_bandwidth(0),
- congestion_window(0),
- slow_start_threshold(0),
packets_reordered(0),
max_sequence_reordering(0),
max_time_reordering_us(0),
@@ -73,8 +71,6 @@
<< ", srtt(us): " << s.srtt_us
<< ", max packet size: " << s.max_packet_size
<< ", estimated bandwidth: " << s.estimated_bandwidth
- << ", congestion window: " << s.congestion_window
- << ", slow start threshold: " << s.slow_start_threshold
<< ", tcp_loss_events: " << s.tcp_loss_events
<< ", packets reordered: " << s.packets_reordered
<< ", max sequence reordering: " << s.max_sequence_reordering
diff --git a/net/quic/quic_connection_stats.h b/net/quic/quic_connection_stats.h
index c681dea..2abdb59 100644
--- a/net/quic/quic_connection_stats.h
+++ b/net/quic/quic_connection_stats.h
@@ -55,8 +55,6 @@
int64 srtt_us; // Smoothed RTT in microseconds.
uint32 max_packet_size; // In bytes.
uint64 estimated_bandwidth; // In bytes per second.
- uint32 congestion_window; // In bytes
- uint32 slow_start_threshold; // In bytes
// Reordering stats for received packets.
// Number of packets received out of sequence number order.
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index b230fd5..66cb89c 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -3676,10 +3676,6 @@
EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillOnce(
Return(QuicBandwidth::Zero()));
- const uint32 kSlowStartThreshold = 23u;
- EXPECT_CALL(*send_algorithm_, GetSlowStartThreshold()).WillOnce(
- Return(kSlowStartThreshold));
-
const QuicConnectionStats& stats = connection_.GetStats();
EXPECT_EQ(3 * first_packet_size + 2 * second_packet_size - kQuicVersionSize,
stats.bytes_sent);
@@ -3688,8 +3684,6 @@
stats.bytes_retransmitted);
EXPECT_EQ(3u, stats.packets_retransmitted);
EXPECT_EQ(1u, stats.rto_count);
- EXPECT_EQ(kMaxPacketSize, stats.congestion_window);
- EXPECT_EQ(kSlowStartThreshold, stats.slow_start_threshold);
EXPECT_EQ(kDefaultMaxPacketSize, stats.max_packet_size);
}
@@ -3705,9 +3699,6 @@
EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillOnce(
Return(QuicBandwidth::Zero()));
- const uint32 kSlowStartThreshold = 23u;
- EXPECT_CALL(*send_algorithm_, GetSlowStartThreshold()).WillOnce(
- Return(kSlowStartThreshold));
const QuicConnectionStats& stats = connection_.GetStats();
EXPECT_EQ(received_bytes, stats.bytes_received);
@@ -3715,8 +3706,6 @@
EXPECT_EQ(1u, stats.packets_revived);
EXPECT_EQ(1u, stats.packets_dropped);
-
- EXPECT_EQ(kSlowStartThreshold, stats.slow_start_threshold);
}
TEST_P(QuicConnectionTest, TestFecGroupLimits) {
diff --git a/net/quic/quic_dispatcher.cc b/net/quic/quic_dispatcher.cc
index cbdd540..aede7c2 100644
--- a/net/quic/quic_dispatcher.cc
+++ b/net/quic/quic_dispatcher.cc
@@ -352,7 +352,8 @@
QuicServerSession* session = new QuicServerSession(
config_,
CreateQuicConnection(connection_id, server_address, client_address),
- this);
+ this,
+ crypto_config_.HasProofSource());
session->InitializeSession(crypto_config_);
return session;
}
diff --git a/net/quic/quic_flags.cc b/net/quic/quic_flags.cc
index 682e06e..8d6dd86 100644
--- a/net/quic/quic_flags.cc
+++ b/net/quic/quic_flags.cc
@@ -36,10 +36,6 @@
// limit.
bool FLAGS_quic_allow_more_open_streams = false;
-// If true, then QUIC connections will only timeout when an alarm fires, never
-// when setting a timeout.
-bool FLAGS_quic_timeouts_only_from_alarms = true;
-
// If true, then QUIC connections will set both idle and overall timeouts in a
// single method.
bool FLAGS_quic_unified_timeouts = true;
diff --git a/net/quic/quic_flags.h b/net/quic/quic_flags.h
index 271b02e..d49f47a 100644
--- a/net/quic/quic_flags.h
+++ b/net/quic/quic_flags.h
@@ -15,7 +15,6 @@
NET_EXPORT_PRIVATE extern bool FLAGS_enable_quic_fec;
NET_EXPORT_PRIVATE extern bool FLAGS_quic_use_bbr_congestion_control;
NET_EXPORT_PRIVATE extern bool FLAGS_quic_allow_more_open_streams;
-NET_EXPORT_PRIVATE extern bool FLAGS_quic_timeouts_only_from_alarms;
NET_EXPORT_PRIVATE extern bool FLAGS_quic_unified_timeouts;
NET_EXPORT_PRIVATE extern bool FLAGS_quic_drop_junk_packets;
NET_EXPORT_PRIVATE extern bool FLAGS_quic_allow_bbr;
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 53be4dd..db97aac 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -232,11 +232,13 @@
&transport_security_state_,
make_scoped_ptr((QuicServerInfo*)nullptr),
DefaultQuicConfig(),
+ /*is_secure=*/false,
base::MessageLoop::current()->
message_loop_proxy().get(),
nullptr));
session_->InitializeSession(QuicServerId(kServerHostname, kServerPort,
- false, PRIVACY_MODE_DISABLED),
+ /*is_secure=*/false,
+ PRIVACY_MODE_DISABLED),
&crypto_config_,
&crypto_client_stream_factory_);
session_->GetCryptoStream()->CryptoConnect();
@@ -285,7 +287,7 @@
QuicPacketSequenceNumber sequence_number) {
return maker_.MakeRstPacket(
sequence_number, true, stream_id_,
- AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
+ AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
}
scoped_ptr<QuicEncryptedPacket> ConstructAckAndRstStreamPacket(
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index ab698f3..62fe895 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -286,7 +286,7 @@
const AlternateProtocolInfo alternate =
session_->http_server_properties()->GetAlternateProtocol(
HostPortPair::FromURL(request_.url));
- EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol);
+ EXPECT_TRUE(alternate.is_broken);
}
void ExpectQuicAlternateProtocolMapping() {
diff --git a/net/quic/quic_packet_creator.cc b/net/quic/quic_packet_creator.cc
index c1700c0..866f05f 100644
--- a/net/quic/quic_packet_creator.cc
+++ b/net/quic/quic_packet_creator.cc
@@ -187,16 +187,14 @@
void QuicPacketCreator::UpdateSequenceNumberLength(
QuicPacketSequenceNumber least_packet_awaited_by_peer,
- QuicByteCount congestion_window) {
+ QuicPacketCount max_packets_in_flight) {
DCHECK_LE(least_packet_awaited_by_peer, sequence_number_ + 1);
// Since the packet creator will not change sequence number length mid FEC
// group, include the size of an FEC group to be safe.
const QuicPacketSequenceNumber current_delta =
max_packets_per_fec_group_ + sequence_number_ + 1
- least_packet_awaited_by_peer;
- const uint64 congestion_window_packets =
- congestion_window / max_packet_length_;
- const uint64 delta = max(current_delta, congestion_window_packets);
+ const uint64 delta = max(current_delta, max_packets_in_flight);
next_sequence_number_length_ =
QuicFramer::GetMinSequenceNumberLength(delta * 4);
}
@@ -505,16 +503,31 @@
}
void QuicPacketCreator::MaybeAddPadding() {
- if (queued_retransmittable_frames_.get() == nullptr) {
- return;
- }
- if (!queued_retransmittable_frames_->HasCryptoHandshake()) {
- return;
- }
if (BytesFree() == 0) {
// Don't pad full packets.
return;
}
+
+ // Since ReserializeAllFrames does not populate queued_retransmittable_frames_
+ // it's not sufficient to simply call
+ // queued_retransmittable_frames_->HasCryptoHandshake().
+ // TODO(rch): we should really make ReserializeAllFrames not be a special
+ // case!
+
+ // If any of the frames in the current packet are on the crypto stream
+ // then they contain handshake messagses, and we should pad them.
+ bool is_handshake = false;
+ for (const QuicFrame& frame : queued_frames_) {
+ if (frame.type == STREAM_FRAME &&
+ frame.stream_frame->stream_id == kCryptoStreamId) {
+ is_handshake = true;
+ break;
+ }
+ }
+ if (!is_handshake) {
+ return;
+ }
+
QuicPaddingFrame padding;
bool success = AddFrame(QuicFrame(&padding), false);
DCHECK(success);
diff --git a/net/quic/quic_packet_creator.h b/net/quic/quic_packet_creator.h
index 1ca8b09..287cde1 100644
--- a/net/quic/quic_packet_creator.h
+++ b/net/quic/quic_packet_creator.h
@@ -65,7 +65,7 @@
// can be safely changed.
void UpdateSequenceNumberLength(
QuicPacketSequenceNumber least_packet_awaited_by_peer,
- QuicByteCount congestion_window);
+ QuicPacketCount max_packets_in_flight);
// The overhead the framing will add for a packet with one frame.
static size_t StreamFramePacketOverhead(
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index 08acdc7..4e03e3a 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -466,6 +466,52 @@
delete serialized.packet;
}
+TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) {
+ scoped_ptr<QuicStreamFrame> stream_frame(
+ new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, /*offset=*/ 0,
+ MakeIOVector("fake handshake message data")));
+ frames_.push_back(QuicFrame(stream_frame.get()));
+ SerializedPacket serialized =
+ creator_.ReserializeAllFrames(frames_,
+ creator_.next_sequence_number_length());
+
+ EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
+ serialized.packet->length());
+ delete serialized.packet;
+}
+
+TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
+ const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP)
+ + GetEncryptionOverhead() + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+ size_t capacity = kDefaultMaxPacketSize - overhead;
+ for (int delta = -5; delta <= 0; ++delta) {
+ string data(capacity + delta, 'A');
+ size_t bytes_free = 0 - delta;
+
+ scoped_ptr<QuicStreamFrame> stream_frame(
+ new QuicStreamFrame(kCryptoStreamId, /*fin=*/ false, kOffset,
+ MakeIOVector(data)));
+ frames_.push_back(QuicFrame(stream_frame.get()));
+ SerializedPacket serialized =
+ creator_.ReserializeAllFrames(frames_,
+ creator_.next_sequence_number_length());
+
+ // If there is not enough space in the packet to fit a padding frame
+ // (1 byte) and to expand the stream frame (another 2 bytes) the packet
+ // will not be padded.
+ if (bytes_free < 3) {
+ EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
+ - bytes_free, serialized.packet->length());
+ } else {
+ EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
+ serialized.packet->length());
+ }
+
+ delete serialized.packet;
+ frames_.clear();
+ }
+}
+
TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) {
QuicConnectionCloseFrame frame;
frame.error_code = QUIC_NO_ERROR;
@@ -760,23 +806,23 @@
size_t max_packets_per_fec_group = 10;
creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
creator_.set_sequence_number(64 - max_packets_per_fec_group);
- creator_.UpdateSequenceNumberLength(2, 10000);
+ creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
creator_.set_sequence_number(64 * 256 - max_packets_per_fec_group);
- creator_.UpdateSequenceNumberLength(2, 10000);
+ creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
creator_.set_sequence_number(64 * 256 * 256 - max_packets_per_fec_group);
- creator_.UpdateSequenceNumberLength(2, 10000);
+ creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
creator_.set_sequence_number(
GG_UINT64_C(64) * 256 * 256 * 256 * 256 - max_packets_per_fec_group);
- creator_.UpdateSequenceNumberLength(2, 10000);
+ creator_.UpdateSequenceNumberLength(2, 10000 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
}
@@ -785,20 +831,21 @@
EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
- creator_.UpdateSequenceNumberLength(1, 10000);
+ creator_.UpdateSequenceNumberLength(1, 10000 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
- creator_.UpdateSequenceNumberLength(1, 10000 * 256);
+ creator_.UpdateSequenceNumberLength(1, 10000 * 256 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
- creator_.UpdateSequenceNumberLength(1, 10000 * 256 * 256);
+ creator_.UpdateSequenceNumberLength(
+ 1, 10000 * 256 * 256 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
creator_.UpdateSequenceNumberLength(
- 1, GG_UINT64_C(1000) * 256 * 256 * 256 * 256);
+ 1, GG_UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize);
EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
creator_.next_sequence_number_length());
}
diff --git a/net/quic/quic_packet_generator.cc b/net/quic/quic_packet_generator.cc
index deb6a9e..2481ddc 100644
--- a/net/quic/quic_packet_generator.cc
+++ b/net/quic/quic_packet_generator.cc
@@ -19,10 +19,10 @@
// avoid losing them both within the same loss episode. On the other hand,
// we expect to be able to recover from any loss in about an RTT.
// We resolve this tradeoff by sending an FEC packet atmost half an RTT,
-// or equivalently, half a cwnd, after the first protected packet. Since we
-// don't want to delay an FEC packet past half an RTT, we set the max FEC
-// group size to be half the current congestion window.
-const float kCongestionWindowMultiplierForFecGroupSize = 0.5;
+// or equivalently, half the max number of in-flight packets, the first
+// protected packet. Since we don't want to delay an FEC packet past half an
+// RTT, we set the max FEC group size to be half the current congestion window.
+const float kMaxPacketsInFlightMultiplierForFecGroupSize = 0.5;
} // namespace
@@ -85,10 +85,10 @@
}
void QuicPacketGenerator::OnCongestionWindowChange(
- QuicByteCount congestion_window) {
+ QuicPacketCount max_packets_in_flight) {
packet_creator_.set_max_packets_per_fec_group(
- static_cast<size_t>(kCongestionWindowMultiplierForFecGroupSize *
- congestion_window / kDefaultTCPMSS));
+ static_cast<size_t>(kMaxPacketsInFlightMultiplierForFecGroupSize *
+ max_packets_in_flight));
}
void QuicPacketGenerator::SetShouldSendAck(bool also_send_feedback,
@@ -378,9 +378,9 @@
void QuicPacketGenerator::UpdateSequenceNumberLength(
QuicPacketSequenceNumber least_packet_awaited_by_peer,
- QuicByteCount congestion_window) {
+ QuicPacketCount max_packets_in_flight) {
return packet_creator_.UpdateSequenceNumberLength(
- least_packet_awaited_by_peer, congestion_window);
+ least_packet_awaited_by_peer, max_packets_in_flight);
}
void QuicPacketGenerator::SetConnectionIdLength(uint32 length) {
diff --git a/net/quic/quic_packet_generator.h b/net/quic/quic_packet_generator.h
index 56c3694..3fec02a 100644
--- a/net/quic/quic_packet_generator.h
+++ b/net/quic/quic_packet_generator.h
@@ -100,7 +100,7 @@
virtual ~QuicPacketGenerator();
// Called by the connection in the event of the congestion window changing.
- void OnCongestionWindowChange(QuicByteCount congestion_window);
+ void OnCongestionWindowChange(QuicPacketCount max_packets_in_flight);
// Indicates that an ACK frame should be sent. If |also_send_feedback| is
// true, then it also indicates a CONGESTION_FEEDBACK frame should be sent.
@@ -165,7 +165,7 @@
// can be safely changed.
void UpdateSequenceNumberLength(
QuicPacketSequenceNumber least_packet_awaited_by_peer,
- QuicByteCount congestion_window);
+ QuicPacketCount max_packets_in_flight);
// Set the minimum number of bytes for the connection id length;
void SetConnectionIdLength(uint32 length);
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index 8ffa34b..3f2472c 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -560,15 +560,15 @@
EXPECT_FALSE(creator_->IsFecGroupOpen());
// On reduced cwnd.
- generator_.OnCongestionWindowChange(7 * kDefaultTCPMSS);
+ generator_.OnCongestionWindowChange(7);
EXPECT_EQ(3u, creator_->max_packets_per_fec_group());
// On increased cwnd.
- generator_.OnCongestionWindowChange(100 * kDefaultTCPMSS);
+ generator_.OnCongestionWindowChange(100);
EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
// On collapsed cwnd.
- generator_.OnCongestionWindowChange(1 * kDefaultTCPMSS);
+ generator_.OnCongestionWindowChange(1);
EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
}
@@ -599,7 +599,7 @@
EXPECT_TRUE(creator_->IsFecGroupOpen());
// Change FEC groupsize.
- generator_.OnCongestionWindowChange(2 * kDefaultTCPMSS);
+ generator_.OnCongestionWindowChange(2);
EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
// Send enough data to trigger one unprotected data packet,
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 64d0c23..afd5ed4 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -60,8 +60,8 @@
const QuicByteCount kDefaultTCPMSS = 1460;
// Maximum size of the initial congestion window in packets.
-const size_t kDefaultInitialWindow = 10;
-const uint32 kMaxInitialWindow = 100;
+const QuicPacketCount kDefaultInitialWindow = 10;
+const QuicPacketCount kMaxInitialWindow = 100;
// Default size of initial flow control window, for both stream and session.
const uint32 kDefaultFlowControlSendWindow = 16 * 1024; // 16 KB
@@ -396,8 +396,9 @@
QUIC_STREAM_PEER_GOING_AWAY,
// The stream has been cancelled.
QUIC_STREAM_CANCELLED,
- // Sending a RST to allow for proper flow control accounting.
- QUIC_RST_FLOW_CONTROL_ACCOUNTING,
+ // Closing stream locally, sending a RST to allow for proper flow control
+ // accounting. Sent in response to a RST from the peer.
+ QUIC_RST_ACKNOWLEDGEMENT,
// No error. Used as bound while iterating.
QUIC_STREAM_LAST_ERROR,
diff --git a/net/quic/quic_protocol_test.cc b/net/quic/quic_protocol_test.cc
index 43a009a..9460906 100644
--- a/net/quic/quic_protocol_test.cc
+++ b/net/quic/quic_protocol_test.cc
@@ -18,9 +18,9 @@
// If we ever add different RST codes, we should have a test akin to the
// following.
- // EXPECT_EQ(QUIC_RST_FLOW_CONTROL_ACCOUNTING, AdjustErrorForVersion(
- // QUIC_RST_FLOW_CONTROL_ACCOUNTING,
- // QUIC_VERSION_18));
+ // EXPECT_EQ(QUIC_RST_ACKNOWLEDGEMENT, AdjustErrorForVersion(
+ // QUIC_RST_ACKNOWLEDGEMENT,
+ // QUIC_VERSION_23));
}
TEST(QuicProtocolTest, MakeQuicTag) {
diff --git a/net/quic/quic_sent_packet_manager.cc b/net/quic/quic_sent_packet_manager.cc
index 6370d9f..bdf8690 100644
--- a/net/quic/quic_sent_packet_manager.cc
+++ b/net/quic/quic_sent_packet_manager.cc
@@ -192,7 +192,7 @@
send_algorithm_->BandwidthEstimate(),
ack_receive_time,
clock_->WallNow(),
- rtt_stats_.SmoothedRtt());
+ rtt_stats_.smoothed_rtt());
// If we have received a truncated ack, then we need to clear out some
// previous transmissions to allow the peer to actually ACK new packets.
@@ -819,15 +819,21 @@
const {
// This is equivalent to the TailLossProbeDelay, but slightly more aggressive
// because crypto handshake messages don't incur a delayed ack time.
- int64 delay_ms =
- max(kMinHandshakeTimeoutMs,
- static_cast<int64>(1.5 * rtt_stats_.SmoothedRtt().ToMilliseconds()));
+ QuicTime::Delta srtt = rtt_stats_.smoothed_rtt();
+ if (srtt.IsZero()) {
+ srtt = QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us());
+ }
+ int64 delay_ms = max(kMinHandshakeTimeoutMs,
+ static_cast<int64>(1.5 * srtt.ToMilliseconds()));
return QuicTime::Delta::FromMilliseconds(
delay_ms << consecutive_crypto_retransmission_count_);
}
const QuicTime::Delta QuicSentPacketManager::GetTailLossProbeDelay() const {
- QuicTime::Delta srtt = rtt_stats_.SmoothedRtt();
+ QuicTime::Delta srtt = rtt_stats_.smoothed_rtt();
+ if (srtt.IsZero()) {
+ srtt = QuicTime::Delta::FromMicroseconds(rtt_stats_.initial_rtt_us());
+ }
if (!unacked_packets_.HasMultipleInFlightPackets()) {
return QuicTime::Delta::Max(
srtt.Multiply(2), srtt.Multiply(1.5).Add(
@@ -865,6 +871,8 @@
}
QuicBandwidth QuicSentPacketManager::BandwidthEstimate() const {
+ // TODO(ianswett): Remove BandwidthEstimate from SendAlgorithmInterface
+ // and implement the logic here.
return send_algorithm_->BandwidthEstimate();
}
@@ -877,12 +885,17 @@
return sustained_bandwidth_recorder_;
}
-QuicByteCount QuicSentPacketManager::GetCongestionWindow() const {
- return send_algorithm_->GetCongestionWindow();
+QuicPacketCount QuicSentPacketManager::EstimateMaxPacketsInFlight(
+ QuicByteCount max_packet_length) const {
+ return send_algorithm_->GetCongestionWindow() / max_packet_length;
}
-QuicByteCount QuicSentPacketManager::GetSlowStartThreshold() const {
- return send_algorithm_->GetSlowStartThreshold();
+QuicPacketCount QuicSentPacketManager::GetCongestionWindowInTcpMss() const {
+ return send_algorithm_->GetCongestionWindow() / kDefaultTCPMSS;
+}
+
+QuicPacketCount QuicSentPacketManager::GetSlowStartThresholdInTcpMss() const {
+ return send_algorithm_->GetSlowStartThreshold() / kDefaultTCPMSS;
}
void QuicSentPacketManager::EnablePacing() {
diff --git a/net/quic/quic_sent_packet_manager.h b/net/quic/quic_sent_packet_manager.h
index cccacab..f82e34b 100644
--- a/net/quic/quic_sent_packet_manager.h
+++ b/net/quic/quic_sent_packet_manager.h
@@ -182,15 +182,22 @@
const QuicSustainedBandwidthRecorder& SustainedBandwidthRecorder() const;
- // Returns the size of the current congestion window in bytes. Note, this is
- // not the *available* window. Some send algorithms may not use a congestion
- // window and will return 0.
- QuicByteCount GetCongestionWindow() const;
+ // Returns the size of the current congestion window in number of
+ // kDefaultTCPMSS-sized segments. Note, this is not the *available* window.
+ // Some send algorithms may not use a congestion window and will return 0.
+ QuicPacketCount GetCongestionWindowInTcpMss() const;
- // Returns the size of the slow start congestion window in bytes,
- // aka ssthresh. Some send algorithms do not define a slow start
- // threshold and will return 0.
- QuicByteCount GetSlowStartThreshold() const;
+ // Returns the number of packets of length |max_packet_length| which fit in
+ // the current congestion window. More packets may end up in flight if the
+ // congestion window has been recently reduced, of if non-full packets are
+ // sent.
+ QuicPacketCount EstimateMaxPacketsInFlight(
+ QuicByteCount max_packet_length) const;
+
+ // Returns the size of the slow start congestion window in nume of 1460 byte
+ // TCP segments, aka ssthresh. Some send algorithms do not define a slow
+ // start threshold and will return 0.
+ QuicPacketCount GetSlowStartThresholdInTcpMss() const;
// Enables pacing if it has not already been enabled.
void EnablePacing();
diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
index bf8c99c..d7a846a 100644
--- a/net/quic/quic_sent_packet_manager_test.cc
+++ b/net/quic/quic_sent_packet_manager_test.cc
@@ -1025,7 +1025,7 @@
QuicSentPacketManagerPeer::GetRttStats(&manager_)->UpdateRtt(
min_rtt, QuicTime::Delta::Zero(), QuicTime::Zero());
EXPECT_EQ(min_rtt,
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->MinRtt());
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
EXPECT_EQ(min_rtt,
QuicSentPacketManagerPeer::GetRttStats(
&manager_)->recent_min_rtt());
@@ -1052,7 +1052,7 @@
manager_.OnIncomingAck(ack_frame, clock_.Now());
EXPECT_EQ(min_rtt,
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->MinRtt());
+ QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
QuicSentPacketManagerPeer::GetRttStats(
&manager_)->recent_min_rtt());
@@ -1079,16 +1079,16 @@
SendCryptoPacket(1);
// Check the min.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 1 * base::Time::kMicrosecondsPerMillisecond);
+ RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+ rtt_stats->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
manager_.GetRetransmissionTime());
// Test with a standard smoothed RTT.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 100 * base::Time::kMicrosecondsPerMillisecond);
+ rtt_stats->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
- QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
+ QuicTime::Delta srtt =
+ QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
QuicTime expected_time = clock_.Now().Add(srtt.Multiply(1.5));
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
@@ -1108,15 +1108,15 @@
SendDataPacket(2);
// Check the min.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 1 * base::Time::kMicrosecondsPerMillisecond);
+ RttStats* rtt_stats = QuicSentPacketManagerPeer::GetRttStats(&manager_);
+ rtt_stats->set_initial_rtt_us(1 * base::Time::kMicrosecondsPerMillisecond);
EXPECT_EQ(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)),
manager_.GetRetransmissionTime());
// Test with a standard smoothed RTT.
- QuicSentPacketManagerPeer::GetRttStats(&manager_)->set_initial_rtt_us(
- 100 * base::Time::kMicrosecondsPerMillisecond);
- QuicTime::Delta srtt = manager_.GetRttStats()->SmoothedRtt();
+ rtt_stats->set_initial_rtt_us(100 * base::Time::kMicrosecondsPerMillisecond);
+ QuicTime::Delta srtt =
+ QuicTime::Delta::FromMicroseconds(rtt_stats->initial_rtt_us());
QuicTime::Delta expected_tlp_delay = srtt.Multiply(2);
QuicTime expected_time = clock_.Now().Add(expected_tlp_delay);
EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
@@ -1420,7 +1420,7 @@
TEST_F(QuicSentPacketManagerTest, UseInitialRoundTripTimeToSend) {
uint32 initial_rtt_us = 325000;
EXPECT_NE(initial_rtt_us,
- manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
+ manager_.GetRttStats()->smoothed_rtt().ToMicroseconds());
QuicConfig config;
config.SetInitialRoundTripTimeUsToSend(initial_rtt_us);
@@ -1428,8 +1428,8 @@
EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
manager_.SetFromConfig(config);
- EXPECT_EQ(initial_rtt_us,
- manager_.GetRttStats()->SmoothedRtt().ToMicroseconds());
+ EXPECT_EQ(0, manager_.GetRttStats()->smoothed_rtt().ToMicroseconds());
+ EXPECT_EQ(initial_rtt_us, manager_.GetRttStats()->initial_rtt_us());
}
} // namespace
diff --git a/net/quic/quic_server.cc b/net/quic/quic_server.cc
index b8013c4..fecb4e5 100644
--- a/net/quic/quic_server.cc
+++ b/net/quic/quic_server.cc
@@ -29,8 +29,6 @@
// the limit.
const int kReadBufferSize = 2 * kMaxPacketSize;
-const uint32 kServerInitialFlowControlWindow = 100 * kMaxPacketSize;
-
} // namespace
QuicServer::QuicServer(const QuicConfig& config,
@@ -53,11 +51,9 @@
QuicInMemoryCache::GetInstance();
scoped_ptr<CryptoHandshakeMessage> scfg(
- crypto_config_.AddDefaultConfig(helper_.GetRandomGenerator(),
- helper_.GetClock(),
- QuicCryptoServerConfig::ConfigOptions()));
-
- config_.SetInitialCongestionWindowToSend(kServerInitialFlowControlWindow);
+ crypto_config_.AddDefaultConfig(
+ helper_.GetRandomGenerator(), helper_.GetClock(),
+ QuicCryptoServerConfig::ConfigOptions()));
}
QuicServer::~QuicServer() {
diff --git a/net/quic/quic_server_session.cc b/net/quic/quic_server_session.cc
index efb0bcf..7fab509 100644
--- a/net/quic/quic_server_session.cc
+++ b/net/quic/quic_server_session.cc
@@ -15,8 +15,9 @@
QuicServerSession::QuicServerSession(const QuicConfig& config,
QuicConnection* connection,
- QuicServerSessionVisitor* visitor)
- : QuicSession(connection, config),
+ QuicServerSessionVisitor* visitor,
+ bool is_secure)
+ : QuicSession(connection, config, is_secure),
visitor_(visitor),
bandwidth_estimate_sent_to_client_(QuicBandwidth::Zero()),
last_scup_time_(QuicTime::Zero()),
@@ -73,7 +74,7 @@
const QuicSentPacketManager& sent_packet_manager =
connection()->sent_packet_manager();
int64 srtt_ms =
- sent_packet_manager.GetRttStats()->SmoothedRtt().ToMilliseconds();
+ sent_packet_manager.GetRttStats()->smoothed_rtt().ToMilliseconds();
int64 now_ms = now.Subtract(last_scup_time_).ToMilliseconds();
int64 packets_since_last_scup =
connection()->sequence_number_of_last_sent_packet() -
@@ -127,7 +128,7 @@
cached_network_params.set_max_bandwidth_timestamp_seconds(
max_bandwidth_timestamp);
cached_network_params.set_min_rtt_ms(
- sent_packet_manager.GetRttStats()->MinRtt().ToMilliseconds());
+ sent_packet_manager.GetRttStats()->min_rtt().ToMilliseconds());
cached_network_params.set_previous_connection_state(
bandwidth_recorder.EstimateRecordedDuringSlowStart()
? CachedNetworkParameters::SLOW_START
diff --git a/net/quic/quic_server_session.h b/net/quic/quic_server_session.h
index 43107a0..a402005 100644
--- a/net/quic/quic_server_session.h
+++ b/net/quic/quic_server_session.h
@@ -46,7 +46,8 @@
public:
QuicServerSession(const QuicConfig& config,
QuicConnection* connection,
- QuicServerSessionVisitor* visitor);
+ QuicServerSessionVisitor* visitor,
+ bool is_secure);
// Override the base class to notify the owner of the connection close.
void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index 4e1fc7b..34a668d 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -95,7 +95,8 @@
QuicSession* session_;
};
-QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config)
+QuicSession::QuicSession(QuicConnection* connection, const QuicConfig& config,
+ bool is_secure)
: connection_(connection),
visitor_shim_(new VisitorShim(this)),
config_(config),
@@ -105,7 +106,8 @@
error_(QUIC_NO_ERROR),
goaway_received_(false),
goaway_sent_(false),
- has_pending_handshake_(false) {
+ has_pending_handshake_(false),
+ is_secure_(is_secure) {
if (connection_->version() == QUIC_VERSION_19) {
flow_controller_.reset(new QuicFlowController(
connection_.get(), 0, is_server(), kDefaultFlowControlSendWindow,
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h
index 1bca3aa..6ca9ce0 100644
--- a/net/quic/quic_session.h
+++ b/net/quic/quic_session.h
@@ -52,7 +52,9 @@
HANDSHAKE_CONFIRMED,
};
- QuicSession(QuicConnection* connection, const QuicConfig& config);
+ QuicSession(QuicConnection* connection,
+ const QuicConfig& config,
+ bool is_secure);
void InitializeSession();
~QuicSession() override;
@@ -209,6 +211,11 @@
// Returns true if any stream is flow controller blocked.
bool IsStreamFlowControlBlocked();
+ // Returns true if this is a secure QUIC session.
+ bool is_secure() const {
+ return is_secure_;
+ }
+
size_t get_max_open_streams() const { return max_open_streams_; }
protected:
@@ -326,6 +333,9 @@
// Used for session level flow control.
scoped_ptr<QuicFlowController> flow_controller_;
+ // True if this is a secure (HTTPS) QUIC session.
+ bool is_secure_;
+
DISALLOW_COPY_AND_ASSIGN(QuicSession);
};
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
index c248460..edbfbee 100644
--- a/net/quic/quic_session_test.cc
+++ b/net/quic/quic_session_test.cc
@@ -126,7 +126,8 @@
public:
explicit TestSession(QuicConnection* connection)
: QuicSession(connection,
- DefaultQuicConfig()),
+ DefaultQuicConfig(),
+ false),
crypto_stream_(this),
writev_consumes_all_data_(false) {
InitializeSession();
@@ -399,7 +400,7 @@
EXPECT_CALL(*send_algorithm, TimeUntilSend(_, _, _)).WillRepeatedly(
Return(QuicTime::Delta::Zero()));
EXPECT_CALL(*send_algorithm, GetCongestionWindow())
- .WillOnce(Return(kMaxPacketSize * 10));
+ .WillRepeatedly(Return(kMaxPacketSize * 10));
EXPECT_CALL(*stream2, OnCanWrite())
.WillOnce(IgnoreResult(Invoke(CreateFunctor(
&session_, &TestSession::SendStreamData, stream2->id()))));
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index 678463e..cf70608 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -946,7 +946,7 @@
*session = new QuicClientSession(
connection, socket.Pass(), this, transport_security_state_,
- server_info.Pass(), config,
+ server_info.Pass(), config, server_id.is_https(),
base::MessageLoop::current()->message_loop_proxy().get(),
net_log.net_log());
all_sessions_[*session] = server_id; // owning pointer
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index 4818620..1165b9c 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -240,7 +240,7 @@
QuicStreamId stream_id = kClientDataStreamId1;
return maker_.MakeRstPacket(
1, true, stream_id,
- AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
+ AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam()));
}
MockQuicServerInfoFactory quic_server_info_factory_;
diff --git a/net/quic/quic_time_wait_list_manager.cc b/net/quic/quic_time_wait_list_manager.cc
index 42dae00..d59cbc4 100644
--- a/net/quic/quic_time_wait_list_manager.cc
+++ b/net/quic/quic_time_wait_list_manager.cc
@@ -27,8 +27,9 @@
namespace {
-// Time period for which the connection_id should live in time wait state..
-const int kTimeWaitSeconds = 5;
+// Time period for which a given connection_id should live in the time-wait
+// state.
+int64 FLAGS_quic_time_wait_list_seconds = 5;
} // namespace
@@ -86,7 +87,8 @@
QuicConnectionHelperInterface* helper,
const QuicVersionVector& supported_versions)
: helper_(helper),
- kTimeWaitPeriod_(QuicTime::Delta::FromSeconds(kTimeWaitSeconds)),
+ kTimeWaitPeriod_(
+ QuicTime::Delta::FromSeconds(FLAGS_quic_time_wait_list_seconds)),
connection_id_clean_up_alarm_(
helper_->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
writer_(writer),
@@ -274,6 +276,7 @@
break;
}
// This connection_id has lived its age, retire it now.
+ DVLOG(1) << "Retiring " << it->first << " from the time-wait state.";
delete it->second.close_packet;
connection_id_map_.erase(it);
}
diff --git a/net/quic/quic_utils.cc b/net/quic/quic_utils.cc
index 908e26f..d786a95 100644
--- a/net/quic/quic_utils.cc
+++ b/net/quic/quic_utils.cc
@@ -138,7 +138,7 @@
RETURN_STRING_LITERAL(QUIC_BAD_APPLICATION_PAYLOAD);
RETURN_STRING_LITERAL(QUIC_STREAM_PEER_GOING_AWAY);
RETURN_STRING_LITERAL(QUIC_STREAM_CANCELLED);
- RETURN_STRING_LITERAL(QUIC_RST_FLOW_CONTROL_ACCOUNTING);
+ RETURN_STRING_LITERAL(QUIC_RST_ACKNOWLEDGEMENT);
RETURN_STRING_LITERAL(QUIC_STREAM_LAST_ERROR);
}
// Return a default value so that we return this when |error| doesn't match
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index 7db9a57..70b6d9a 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -457,7 +457,7 @@
// written on this stream before termination. Done here if needed, using a
// RST frame.
DVLOG(1) << ENDPOINT << "Sending RST in OnClose: " << id();
- session_->SendRstStream(id(), QUIC_RST_FLOW_CONTROL_ACCOUNTING,
+ session_->SendRstStream(id(), QUIC_RST_ACKNOWLEDGEMENT,
stream_bytes_written_);
rst_sent_ = true;
}
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index fad194b..ae3abfe 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -316,7 +316,7 @@
}
MockSession::MockSession(QuicConnection* connection)
- : QuicSession(connection, DefaultQuicConfig()) {
+ : QuicSession(connection, DefaultQuicConfig(), /*is_secure=*/false) {
InitializeSession();
ON_CALL(*this, WritevData(_, _, _, _, _, _))
.WillByDefault(testing::Return(QuicConsumedData(0, false)));
@@ -326,7 +326,8 @@
}
TestSession::TestSession(QuicConnection* connection, const QuicConfig& config)
- : QuicSession(connection, config), crypto_stream_(nullptr) {
+ : QuicSession(connection, config, /*is_secure=*/false),
+ crypto_stream_(nullptr) {
InitializeSession();
}
@@ -342,7 +343,7 @@
TestClientSession::TestClientSession(QuicConnection* connection,
const QuicConfig& config)
- : QuicClientSessionBase(connection, config),
+ : QuicClientSessionBase(connection, config, /*is_secure=*/false),
crypto_stream_(nullptr) {
EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
InitializeSession();
