Revved to chromium 4dfb55c9cf0950b8bac8b10070c9b8f3e7de66c2 refs/remotes/origin/HEAD
diff --git a/net/quic/congestion_control/cubic.cc b/net/quic/congestion_control/cubic.cc
index dec529d..22b0a90 100644
--- a/net/quic/congestion_control/cubic.cc
+++ b/net/quic/congestion_control/cubic.cc
@@ -82,8 +82,8 @@
QuicTcpCongestionWindow new_cubic_mode_cwnd,
QuicTcpCongestionWindow new_reno_mode_cwnd) {
- QuicTcpCongestionWindow highest_new_cwnd = std::max(new_cubic_mode_cwnd,
- new_reno_mode_cwnd);
+ QuicTcpCongestionWindow highest_new_cwnd = max(new_cubic_mode_cwnd,
+ new_reno_mode_cwnd);
if (last_congestion_window_ < highest_new_cwnd) {
// cwnd will increase to highest_new_cwnd.
stats_->cwnd_increase_congestion_avoidance +=
diff --git a/net/quic/congestion_control/hybrid_slow_start.cc b/net/quic/congestion_control/hybrid_slow_start.cc
index 2ae3b50..4b1e842 100644
--- a/net/quic/congestion_control/hybrid_slow_start.cc
+++ b/net/quic/congestion_control/hybrid_slow_start.cc
@@ -18,8 +18,8 @@
const uint32 kHybridStartMinSamples = 8;
const int kHybridStartDelayFactorExp = 4; // 2^4 = 16
// The original paper specifies 2 and 8ms, but those have changed over time.
-const int kHybridStartDelayMinThresholdUs = 4000;
-const int kHybridStartDelayMaxThresholdUs = 16000;
+const int64 kHybridStartDelayMinThresholdUs = 4000;
+const int64 kHybridStartDelayMaxThresholdUs = 16000;
HybridSlowStart::HybridSlowStart(const QuicClock* clock)
: clock_(clock),
@@ -116,7 +116,7 @@
// We only need to check this once per round.
if (rtt_sample_count_ == kHybridStartMinSamples) {
// Divide min_rtt by 16 to get a rtt increase threshold for exiting.
- int min_rtt_increase_threshold_us = min_rtt.ToMicroseconds() >>
+ int64 min_rtt_increase_threshold_us = min_rtt.ToMicroseconds() >>
kHybridStartDelayFactorExp;
// Ensure the rtt threshold is never less than 2ms or more than 16ms.
min_rtt_increase_threshold_us = min(min_rtt_increase_threshold_us,
diff --git a/net/quic/congestion_control/pacing_sender.cc b/net/quic/congestion_control/pacing_sender.cc
index 20d2b3b..03e5534 100644
--- a/net/quic/congestion_control/pacing_sender.cc
+++ b/net/quic/congestion_control/pacing_sender.cc
@@ -15,15 +15,12 @@
burst_tokens_(initial_packet_burst),
last_delayed_packet_sent_time_(QuicTime::Zero()),
next_packet_send_time_(QuicTime::Zero()),
- was_last_send_delayed_(false),
- has_valid_rtt_(false) {
+ was_last_send_delayed_(false) {
}
PacingSender::~PacingSender() {}
void PacingSender::SetFromConfig(const QuicConfig& config, bool is_server) {
- // TODO(ianswett): Consider using the suggested RTT for pacing an initial
- // response.
sender_->SetFromConfig(config, is_server);
}
@@ -42,9 +39,6 @@
QuicByteCount bytes_in_flight,
const CongestionVector& acked_packets,
const CongestionVector& lost_packets) {
- if (rtt_updated) {
- has_valid_rtt_ = true;
- }
sender_->OnCongestionEvent(
rtt_updated, bytes_in_flight, acked_packets, lost_packets);
}
@@ -55,11 +49,10 @@
QuicPacketSequenceNumber sequence_number,
QuicByteCount bytes,
HasRetransmittableData has_retransmittable_data) {
- // Only pace data packets once we have an updated RTT.
const bool in_flight =
sender_->OnPacketSent(sent_time, bytes_in_flight, sequence_number,
bytes, has_retransmittable_data);
- if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA || !has_valid_rtt_) {
+ if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA) {
return in_flight;
}
if (burst_tokens_ > 0) {
@@ -117,10 +110,6 @@
HasRetransmittableData has_retransmittable_data) const {
QuicTime::Delta time_until_send =
sender_->TimeUntilSend(now, bytes_in_flight, has_retransmittable_data);
- if (!has_valid_rtt_) {
- // Don't pace if we don't have an updated RTT estimate.
- return time_until_send;
- }
if (bytes_in_flight == 0) {
// Add more burst tokens anytime the connection is entering quiescence.
burst_tokens_ = initial_packet_burst_;
@@ -143,6 +132,8 @@
}
// If the next send time is within the alarm granularity, send immediately.
+ // TODO(ianswett): This granularity logic ends up sending more packets than
+ // intended in an effort to make up for lost time that wasn't lost.
if (next_packet_send_time_ > now.Add(alarm_granularity_)) {
DVLOG(1) << "Delaying packet: "
<< next_packet_send_time_.Subtract(now).ToMicroseconds();
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index f61ae75..e50527d 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -35,34 +35,34 @@
virtual ~PacingSender();
// SendAlgorithmInterface methods.
- virtual void SetFromConfig(const QuicConfig& config, bool is_server) OVERRIDE;
- virtual void SetNumEmulatedConnections(int num_connections) OVERRIDE;
+ virtual void SetFromConfig(const QuicConfig& config, bool is_server) override;
+ virtual void SetNumEmulatedConnections(int num_connections) override;
virtual void OnIncomingQuicCongestionFeedbackFrame(
const QuicCongestionFeedbackFrame& feedback,
- QuicTime feedback_receive_time) OVERRIDE;
+ QuicTime feedback_receive_time) override;
virtual void OnCongestionEvent(bool rtt_updated,
QuicByteCount bytes_in_flight,
const CongestionVector& acked_packets,
- const CongestionVector& lost_packets) OVERRIDE;
+ const CongestionVector& lost_packets) override;
virtual bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
QuicPacketSequenceNumber sequence_number,
QuicByteCount bytes,
- HasRetransmittableData is_retransmittable) OVERRIDE;
- virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
- virtual void RevertRetransmissionTimeout() OVERRIDE;
+ HasRetransmittableData is_retransmittable) override;
+ virtual void OnRetransmissionTimeout(bool packets_retransmitted) override;
+ virtual void RevertRetransmissionTimeout() override;
virtual QuicTime::Delta TimeUntilSend(
QuicTime now,
QuicByteCount bytes_in_flight,
- HasRetransmittableData has_retransmittable_data) const OVERRIDE;
- virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
- virtual bool HasReliableBandwidthEstimate() const OVERRIDE;
- virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
- virtual QuicByteCount GetCongestionWindow() const OVERRIDE;
- virtual bool InSlowStart() const OVERRIDE;
- virtual bool InRecovery() const OVERRIDE;
- virtual QuicByteCount GetSlowStartThreshold() const OVERRIDE;
- virtual CongestionControlType GetCongestionControlType() const OVERRIDE;
+ HasRetransmittableData has_retransmittable_data) const override;
+ virtual QuicBandwidth BandwidthEstimate() const override;
+ virtual bool HasReliableBandwidthEstimate() const override;
+ virtual QuicTime::Delta RetransmissionDelay() const override;
+ virtual QuicByteCount GetCongestionWindow() const override;
+ virtual bool InSlowStart() const override;
+ virtual bool InRecovery() const override;
+ virtual QuicByteCount GetSlowStartThreshold() const override;
+ virtual CongestionControlType GetCongestionControlType() const override;
private:
scoped_ptr<SendAlgorithmInterface> sender_; // Underlying sender.
@@ -73,7 +73,6 @@
QuicTime last_delayed_packet_sent_time_;
QuicTime next_packet_send_time_; // When can the next packet be sent.
mutable bool was_last_send_delayed_; // True when the last send was delayed.
- bool has_valid_rtt_; // True if we have at least one RTT update.
DISALLOW_COPY_AND_ASSIGN(PacingSender);
};
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index 768cc22..f887c54 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -19,6 +19,7 @@
namespace test {
const QuicByteCount kBytesInFlight = 1024;
+const int kInitialBurstPackets = 10;
class PacingSenderTest : public ::testing::Test {
protected:
@@ -142,11 +143,6 @@
.WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
- // Send a whole pile of packets, and verify that they are not paced.
- for (int i = 0 ; i < 1000; ++i) {
- CheckPacketIsSentImmediately();
- }
-
// Now update the RTT and verify that packets are actually paced.
EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
SendAlgorithmInterface::CongestionVector empty_map;
@@ -217,11 +213,6 @@
.WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
- // Send a whole pile of packets, and verify that they are not paced.
- for (int i = 0 ; i < 1000; ++i) {
- CheckPacketIsSentImmediately();
- }
-
// Now update the RTT and verify that packets are actually paced.
EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
SendAlgorithmInterface::CongestionVector empty_map;
@@ -296,17 +287,17 @@
pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map, empty_map);
// Send 10 packets, and verify that they are not paced.
- for (int i = 0 ; i < 10; ++i) {
+ for (int i = 0 ; i < kInitialBurstPackets; ++i) {
CheckPacketIsSentImmediately();
}
- CheckPacketIsSentImmediately();
- CheckPacketIsSentImmediately();
- CheckPacketIsSentImmediately();
-
// The first packet was a "make up", then we sent two packets "into the
- // future", so the delay should be 2.
+ // future", so the delay should be 2ms.
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+
clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
CheckPacketIsSentImmediately();
@@ -321,14 +312,70 @@
pacing_sender_->TimeUntilSend(clock_.Now(),
0,
HAS_RETRANSMITTABLE_DATA));
- for (int i = 0 ; i < 10; ++i) {
+ for (int i = 0 ; i < kInitialBurstPackets; ++i) {
CheckPacketIsSentImmediately();
}
+ // The first packet was a "make up", then we sent two packets "into the
+ // future", so the delay should be 2ms.
CheckPacketIsSentImmediately();
CheckPacketIsSentImmediately();
CheckPacketIsSentImmediately();
+ CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+}
+
+TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
+ pacing_sender_.reset();
+ mock_sender_ = new StrictMock<MockSendAlgorithm>();
+ pacing_sender_.reset(new PacingSender(mock_sender_,
+ QuicTime::Delta::FromMilliseconds(1),
+ 10));
+ // Start the test in slow start.
+ EXPECT_CALL(*mock_sender_, InSlowStart()).WillRepeatedly(Return(true));
+
+ // Configure bandwith of 1 packet per 2 ms, for which the pacing rate
+ // will be 1 packet per 1 ms.
+ EXPECT_CALL(*mock_sender_, BandwidthEstimate())
+ .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
+ kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
+
+ // Send 10 packets, and verify that they are not paced.
+ for (int i = 0 ; i < kInitialBurstPackets; ++i) {
+ CheckPacketIsSentImmediately();
+ }
+
+ // The first packet was a "make up", then we sent two packets "into the
+ // future", so the delay should be 2ms.
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
+ CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+
+
+ clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+ CheckPacketIsSentImmediately();
+ // Next time TimeUntilSend is called with no bytes in flight, the tokens
+ // should be refilled and there should be no delay.
+ EXPECT_CALL(*mock_sender_,
+ TimeUntilSend(clock_.Now(),
+ 0,
+ HAS_RETRANSMITTABLE_DATA)).
+ WillOnce(Return(zero_time_));
+ EXPECT_EQ(zero_time_,
+ pacing_sender_->TimeUntilSend(clock_.Now(),
+ 0,
+ HAS_RETRANSMITTABLE_DATA));
+ // Send 10 packets, and verify that they are not paced.
+ for (int i = 0 ; i < kInitialBurstPackets; ++i) {
+ CheckPacketIsSentImmediately();
+ }
+
+ // The first packet was a "make up", then we sent two packets "into the
+ // future", so the delay should be 2ms.
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
+ CheckPacketIsSentImmediately();
CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
}
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index 8851ac4..dd0df58 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -38,34 +38,34 @@
virtual ~TcpCubicSender();
// Start implementation of SendAlgorithmInterface.
- virtual void SetFromConfig(const QuicConfig& config, bool is_server) OVERRIDE;
- virtual void SetNumEmulatedConnections(int num_connections) OVERRIDE;
+ virtual void SetFromConfig(const QuicConfig& config, bool is_server) override;
+ virtual void SetNumEmulatedConnections(int num_connections) override;
virtual void OnIncomingQuicCongestionFeedbackFrame(
const QuicCongestionFeedbackFrame& feedback,
- QuicTime feedback_receive_time) OVERRIDE;
+ QuicTime feedback_receive_time) override;
virtual void OnCongestionEvent(bool rtt_updated,
QuicByteCount bytes_in_flight,
const CongestionVector& acked_packets,
- const CongestionVector& lost_packets) OVERRIDE;
+ const CongestionVector& lost_packets) override;
virtual bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
QuicPacketSequenceNumber sequence_number,
QuicByteCount bytes,
- HasRetransmittableData is_retransmittable) OVERRIDE;
- virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
- virtual void RevertRetransmissionTimeout() OVERRIDE;
+ HasRetransmittableData is_retransmittable) override;
+ virtual void OnRetransmissionTimeout(bool packets_retransmitted) override;
+ virtual void RevertRetransmissionTimeout() override;
virtual QuicTime::Delta TimeUntilSend(
QuicTime now,
QuicByteCount bytes_in_flight,
- HasRetransmittableData has_retransmittable_data) const OVERRIDE;
- virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
- virtual bool HasReliableBandwidthEstimate() const OVERRIDE;
- virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
- virtual QuicByteCount GetCongestionWindow() const OVERRIDE;
- virtual bool InSlowStart() const OVERRIDE;
- virtual bool InRecovery() const OVERRIDE;
- virtual QuicByteCount GetSlowStartThreshold() const OVERRIDE;
- virtual CongestionControlType GetCongestionControlType() const OVERRIDE;
+ HasRetransmittableData has_retransmittable_data) const override;
+ virtual QuicBandwidth BandwidthEstimate() const override;
+ virtual bool HasReliableBandwidthEstimate() const override;
+ virtual QuicTime::Delta RetransmissionDelay() const override;
+ virtual QuicByteCount GetCongestionWindow() const override;
+ virtual bool InSlowStart() const override;
+ virtual bool InRecovery() const override;
+ virtual QuicByteCount GetSlowStartThreshold() const override;
+ virtual CongestionControlType GetCongestionControlType() const override;
// End implementation of SendAlgorithmInterface.
private:
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 851c1a1..731b8f5 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -670,8 +670,8 @@
expected_send_window /= 2;
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
- // No congestion window growth should occur in recovery phase, i.e.,
- // until the currently outstanding 20 packets are acked.
+ // No congestion window growth should occur in recovery phase, i.e., until the
+ // currently outstanding 20 packets are acked.
for (int i = 0; i < 10; ++i) {
// Send our full send window.
SendAvailableSendWindow();
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.cc b/net/quic/congestion_control/tcp_loss_algorithm.cc
index 557681e..b0a5a15 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm.cc
@@ -46,7 +46,9 @@
}
LOG_IF(DFATAL, it->nack_count == 0)
- << "All packets less than largest observed should have been nacked.";
+ << "All packets less than largest observed should have been nacked."
+ << "sequence_number:" << sequence_number
+ << " largest_observed:" << largest_observed;
if (it->nack_count >= kNumberOfNacksBeforeRetransmission) {
lost_packets.insert(sequence_number);
continue;
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.h b/net/quic/congestion_control/tcp_loss_algorithm.h
index 5f0bcfb..201354b 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.h
+++ b/net/quic/congestion_control/tcp_loss_algorithm.h
@@ -23,17 +23,17 @@
TCPLossAlgorithm();
virtual ~TCPLossAlgorithm() {}
- virtual LossDetectionType GetLossDetectionType() const OVERRIDE;
+ virtual LossDetectionType GetLossDetectionType() const override;
// Uses nack counts to decide when packets are lost.
virtual SequenceNumberSet DetectLostPackets(
const QuicUnackedPacketMap& unacked_packets,
const QuicTime& time,
QuicPacketSequenceNumber largest_observed,
- const RttStats& rtt_stats) OVERRIDE;
+ const RttStats& rtt_stats) override;
// Returns a non-zero value when the early retransmit timer is active.
- virtual QuicTime GetLossTimeout() const OVERRIDE;
+ virtual QuicTime GetLossTimeout() const override;
private:
QuicTime loss_detection_timeout_;
diff --git a/net/quic/congestion_control/tcp_receiver.h b/net/quic/congestion_control/tcp_receiver.h
index a5e5b1b..89e9186 100644
--- a/net/quic/congestion_control/tcp_receiver.h
+++ b/net/quic/congestion_control/tcp_receiver.h
@@ -25,11 +25,11 @@
// Start implementation of SendAlgorithmInterface.
virtual bool GenerateCongestionFeedback(
- QuicCongestionFeedbackFrame* feedback) OVERRIDE;
+ QuicCongestionFeedbackFrame* feedback) override;
virtual void RecordIncomingPacket(QuicByteCount bytes,
QuicPacketSequenceNumber sequence_number,
- QuicTime timestamp) OVERRIDE;
+ QuicTime timestamp) override;
private:
QuicByteCount receive_window_;
diff --git a/net/quic/congestion_control/time_loss_algorithm.h b/net/quic/congestion_control/time_loss_algorithm.h
index ae37e1e..de517ef 100644
--- a/net/quic/congestion_control/time_loss_algorithm.h
+++ b/net/quic/congestion_control/time_loss_algorithm.h
@@ -23,7 +23,7 @@
TimeLossAlgorithm();
virtual ~TimeLossAlgorithm() {}
- virtual LossDetectionType GetLossDetectionType() const OVERRIDE;
+ virtual LossDetectionType GetLossDetectionType() const override;
// Declares pending packets less than the largest observed lost when it has
// been 1.25 RTT since they were sent. Packets larger than the largest
@@ -32,14 +32,14 @@
const QuicUnackedPacketMap& unacked_packets,
const QuicTime& time,
QuicPacketSequenceNumber largest_observed,
- const RttStats& rtt_stats) OVERRIDE;
+ const RttStats& rtt_stats) override;
// Returns the time the next packet will be lost, or zero if there
// are no nacked pending packets outstanding.
// TODO(ianswett): Ideally the RTT variance and the RTT would be used to
// determine the time a packet is considered lost.
// TODO(ianswett): Consider using Max(1.25 * srtt, 1.125 * last_rtt).
- virtual QuicTime GetLossTimeout() const OVERRIDE;
+ virtual QuicTime GetLossTimeout() const override;
private:
QuicTime loss_detection_timeout_;
diff --git a/net/quic/crypto/aead_base_decrypter.h b/net/quic/crypto/aead_base_decrypter.h
index 6257409..116dbe1 100644
--- a/net/quic/crypto/aead_base_decrypter.h
+++ b/net/quic/crypto/aead_base_decrypter.h
@@ -40,18 +40,18 @@
virtual ~AeadBaseDecrypter();
// QuicDecrypter implementation
- virtual bool SetKey(base::StringPiece key) OVERRIDE;
- virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+ virtual bool SetKey(base::StringPiece key) override;
+ virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
virtual bool Decrypt(base::StringPiece nonce,
base::StringPiece associated_data,
base::StringPiece ciphertext,
unsigned char* output,
- size_t* output_length) OVERRIDE;
+ size_t* output_length) override;
virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
base::StringPiece associated_data,
- base::StringPiece ciphertext) OVERRIDE;
- virtual base::StringPiece GetKey() const OVERRIDE;
- virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+ base::StringPiece ciphertext) override;
+ virtual base::StringPiece GetKey() const override;
+ virtual base::StringPiece GetNoncePrefix() const override;
protected:
// Make these constants available to the subclasses so that the subclasses
diff --git a/net/quic/crypto/aead_base_encrypter.h b/net/quic/crypto/aead_base_encrypter.h
index 7138131..89c7a1f 100644
--- a/net/quic/crypto/aead_base_encrypter.h
+++ b/net/quic/crypto/aead_base_encrypter.h
@@ -40,21 +40,21 @@
virtual ~AeadBaseEncrypter();
// QuicEncrypter implementation
- virtual bool SetKey(base::StringPiece key) OVERRIDE;
- virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+ virtual bool SetKey(base::StringPiece key) override;
+ virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
virtual bool Encrypt(base::StringPiece nonce,
base::StringPiece associated_data,
base::StringPiece plaintext,
- unsigned char* output) OVERRIDE;
+ unsigned char* output) override;
virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
base::StringPiece associated_data,
- base::StringPiece plaintext) OVERRIDE;
- virtual size_t GetKeySize() const OVERRIDE;
- virtual size_t GetNoncePrefixSize() const OVERRIDE;
- virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE;
- virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE;
- virtual base::StringPiece GetKey() const OVERRIDE;
- virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+ base::StringPiece plaintext) override;
+ virtual size_t GetKeySize() const override;
+ virtual size_t GetNoncePrefixSize() const override;
+ virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
+ virtual size_t GetCiphertextSize(size_t plaintext_size) const override;
+ virtual base::StringPiece GetKey() const override;
+ virtual base::StringPiece GetNoncePrefix() const override;
protected:
// Make these constants available to the subclasses so that the subclasses
diff --git a/net/quic/crypto/aes_128_gcm_12_decrypter.h b/net/quic/crypto/aes_128_gcm_12_decrypter.h
index 0511c8b..4395dc2 100644
--- a/net/quic/crypto/aes_128_gcm_12_decrypter.h
+++ b/net/quic/crypto/aes_128_gcm_12_decrypter.h
@@ -31,7 +31,7 @@
virtual void FillAeadParams(base::StringPiece nonce,
base::StringPiece associated_data,
size_t auth_tag_size,
- AeadParams* aead_params) const OVERRIDE;
+ AeadParams* aead_params) const override;
#endif
private:
diff --git a/net/quic/crypto/aes_128_gcm_12_encrypter.h b/net/quic/crypto/aes_128_gcm_12_encrypter.h
index 1d8f321..afbeb14 100644
--- a/net/quic/crypto/aes_128_gcm_12_encrypter.h
+++ b/net/quic/crypto/aes_128_gcm_12_encrypter.h
@@ -31,7 +31,7 @@
virtual void FillAeadParams(base::StringPiece nonce,
base::StringPiece associated_data,
size_t auth_tag_size,
- AeadParams* aead_params) const OVERRIDE;
+ AeadParams* aead_params) const override;
#endif
private:
diff --git a/net/quic/crypto/chacha20_poly1305_decrypter.h b/net/quic/crypto/chacha20_poly1305_decrypter.h
index 9d24ba2..e3c3e7f 100644
--- a/net/quic/crypto/chacha20_poly1305_decrypter.h
+++ b/net/quic/crypto/chacha20_poly1305_decrypter.h
@@ -35,7 +35,7 @@
virtual void FillAeadParams(base::StringPiece nonce,
base::StringPiece associated_data,
size_t auth_tag_size,
- AeadParams* aead_params) const OVERRIDE;
+ AeadParams* aead_params) const override;
#endif
private:
diff --git a/net/quic/crypto/chacha20_poly1305_encrypter.h b/net/quic/crypto/chacha20_poly1305_encrypter.h
index 4a68caa..b99fa27 100644
--- a/net/quic/crypto/chacha20_poly1305_encrypter.h
+++ b/net/quic/crypto/chacha20_poly1305_encrypter.h
@@ -35,7 +35,7 @@
virtual void FillAeadParams(base::StringPiece nonce,
base::StringPiece associated_data,
size_t auth_tag_size,
- AeadParams* aead_params) const OVERRIDE;
+ AeadParams* aead_params) const override;
#endif
private:
diff --git a/net/quic/crypto/channel_id_chromium.h b/net/quic/crypto/channel_id_chromium.h
index 08cfff9..72f694d 100644
--- a/net/quic/crypto/channel_id_chromium.h
+++ b/net/quic/crypto/channel_id_chromium.h
@@ -24,8 +24,8 @@
// ChannelIDKey interface
virtual bool Sign(base::StringPiece signed_data,
- std::string* out_signature) const OVERRIDE;
- virtual std::string SerializeKey() const OVERRIDE;
+ std::string* out_signature) const override;
+ virtual std::string SerializeKey() const override;
private:
scoped_ptr<crypto::ECPrivateKey> ec_private_key_;
@@ -42,7 +42,7 @@
virtual QuicAsyncStatus GetChannelIDKey(
const std::string& hostname,
scoped_ptr<ChannelIDKey>* channel_id_key,
- ChannelIDSourceCallback* callback) OVERRIDE;
+ ChannelIDSourceCallback* callback) override;
private:
class Job;
diff --git a/net/quic/crypto/common_cert_set.cc b/net/quic/crypto/common_cert_set.cc
index f631cd6..0d39ecc 100644
--- a/net/quic/crypto/common_cert_set.cc
+++ b/net/quic/crypto/common_cert_set.cc
@@ -69,12 +69,12 @@
class CommonCertSetsQUIC : public CommonCertSets {
public:
// CommonCertSets interface.
- virtual StringPiece GetCommonHashes() const OVERRIDE {
+ virtual StringPiece GetCommonHashes() const override {
return StringPiece(reinterpret_cast<const char*>(kSetHashes),
sizeof(uint64) * arraysize(kSetHashes));
}
- virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
+ virtual StringPiece GetCert(uint64 hash, uint32 index) const override {
for (size_t i = 0; i < arraysize(kSets); i++) {
if (kSets[i].hash == hash) {
if (index < kSets[i].num_certs) {
@@ -90,7 +90,7 @@
}
virtual bool MatchCert(StringPiece cert, StringPiece common_set_hashes,
- uint64* out_hash, uint32* out_index) const OVERRIDE {
+ uint64* out_hash, uint32* out_index) const override {
if (common_set_hashes.size() % sizeof(uint64) != 0) {
return false;
}
diff --git a/net/quic/crypto/crypto_framer.cc b/net/quic/crypto/crypto_framer.cc
index bc5c8b7..3f61115 100644
--- a/net/quic/crypto/crypto_framer.cc
+++ b/net/quic/crypto/crypto_framer.cc
@@ -26,10 +26,10 @@
public:
OneShotVisitor() : error_(false) {}
- virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
+ virtual void OnError(CryptoFramer* framer) override { error_ = true; }
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE {
+ const CryptoHandshakeMessage& message) override {
out_.reset(new CryptoHandshakeMessage(message));
}
diff --git a/net/quic/crypto/crypto_framer_test.cc b/net/quic/crypto/crypto_framer_test.cc
index 01e9157..f9ea55d 100644
--- a/net/quic/crypto/crypto_framer_test.cc
+++ b/net/quic/crypto/crypto_framer_test.cc
@@ -33,13 +33,13 @@
public:
TestCryptoVisitor() : error_count_(0) {}
- virtual void OnError(CryptoFramer* framer) OVERRIDE {
+ virtual void OnError(CryptoFramer* framer) override {
DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
++error_count_;
}
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE {
+ const CryptoHandshakeMessage& message) override {
messages_.push_back(message);
}
diff --git a/net/quic/crypto/crypto_server_test.cc b/net/quic/crypto/crypto_server_test.cc
index bb47cbf..1f3380a 100644
--- a/net/quic/crypto/crypto_server_test.cc
+++ b/net/quic/crypto/crypto_server_test.cc
@@ -156,7 +156,7 @@
}
virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
- const Result& result) OVERRIDE {
+ const Result& result) override {
{
// Ensure that the strike register client lock is not held.
QuicCryptoServerConfigPeer peer(&test_->config_);
diff --git a/net/quic/crypto/curve25519_key_exchange.h b/net/quic/crypto/curve25519_key_exchange.h
index 93288f6..310c614 100644
--- a/net/quic/crypto/curve25519_key_exchange.h
+++ b/net/quic/crypto/curve25519_key_exchange.h
@@ -31,11 +31,11 @@
static std::string NewPrivateKey(QuicRandom* rand);
// KeyExchange interface.
- virtual KeyExchange* NewKeyPair(QuicRandom* rand) const OVERRIDE;
+ virtual KeyExchange* NewKeyPair(QuicRandom* rand) const override;
virtual bool CalculateSharedKey(const base::StringPiece& peer_public_value,
- std::string* shared_key) const OVERRIDE;
- virtual base::StringPiece public_value() const OVERRIDE;
- virtual QuicTag tag() const OVERRIDE;
+ std::string* shared_key) const override;
+ virtual base::StringPiece public_value() const override;
+ virtual QuicTag tag() const override;
private:
Curve25519KeyExchange();
diff --git a/net/quic/crypto/local_strike_register_client.h b/net/quic/crypto/local_strike_register_client.h
index fe8ae93..b121299 100644
--- a/net/quic/crypto/local_strike_register_client.h
+++ b/net/quic/crypto/local_strike_register_client.h
@@ -26,10 +26,10 @@
const uint8 orbit[8],
StrikeRegister::StartupType startup);
- virtual bool IsKnownOrbit(base::StringPiece orbit) const OVERRIDE;
+ virtual bool IsKnownOrbit(base::StringPiece orbit) const override;
virtual void VerifyNonceIsValidAndUnique(base::StringPiece nonce,
QuicWallTime now,
- ResultCallback* cb) OVERRIDE;
+ ResultCallback* cb) override;
private:
mutable base::Lock m_;
diff --git a/net/quic/crypto/local_strike_register_client_test.cc b/net/quic/crypto/local_strike_register_client_test.cc
index 1a3b6f9..70d2428 100644
--- a/net/quic/crypto/local_strike_register_client_test.cc
+++ b/net/quic/crypto/local_strike_register_client_test.cc
@@ -36,7 +36,7 @@
protected:
virtual void RunImpl(bool nonce_is_valid_and_unique,
- InsertStatus nonce_error) OVERRIDE {
+ InsertStatus nonce_error) override {
*called_ = true;
*saved_value_ = nonce_is_valid_and_unique;
*saved_nonce_error_ = nonce_error;
diff --git a/net/quic/crypto/null_decrypter.h b/net/quic/crypto/null_decrypter.h
index 2bc2fe8..03038bd 100644
--- a/net/quic/crypto/null_decrypter.h
+++ b/net/quic/crypto/null_decrypter.h
@@ -22,18 +22,18 @@
virtual ~NullDecrypter() {}
// QuicDecrypter implementation
- virtual bool SetKey(base::StringPiece key) OVERRIDE;
- virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+ virtual bool SetKey(base::StringPiece key) override;
+ virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
virtual bool Decrypt(base::StringPiece nonce,
base::StringPiece associated_data,
base::StringPiece ciphertext,
unsigned char* output,
- size_t* output_length) OVERRIDE;
+ size_t* output_length) override;
virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
base::StringPiece associated_data,
- base::StringPiece ciphertext) OVERRIDE;
- virtual base::StringPiece GetKey() const OVERRIDE;
- virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+ base::StringPiece ciphertext) override;
+ virtual base::StringPiece GetKey() const override;
+ virtual base::StringPiece GetNoncePrefix() const override;
private:
bool ReadHash(QuicDataReader* reader, uint128* hash);
diff --git a/net/quic/crypto/null_encrypter.h b/net/quic/crypto/null_encrypter.h
index 1bcdff5..fbd2dff 100644
--- a/net/quic/crypto/null_encrypter.h
+++ b/net/quic/crypto/null_encrypter.h
@@ -20,21 +20,21 @@
virtual ~NullEncrypter() {}
// QuicEncrypter implementation
- virtual bool SetKey(base::StringPiece key) OVERRIDE;
- virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+ virtual bool SetKey(base::StringPiece key) override;
+ virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
virtual bool Encrypt(base::StringPiece nonce,
base::StringPiece associated_data,
base::StringPiece plaintext,
- unsigned char* output) OVERRIDE;
+ unsigned char* output) override;
virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
base::StringPiece associated_data,
- base::StringPiece plaintext) OVERRIDE;
- virtual size_t GetKeySize() const OVERRIDE;
- virtual size_t GetNoncePrefixSize() const OVERRIDE;
- virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE;
- virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE;
- virtual base::StringPiece GetKey() const OVERRIDE;
- virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+ base::StringPiece plaintext) override;
+ virtual size_t GetKeySize() const override;
+ virtual size_t GetNoncePrefixSize() const override;
+ virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
+ virtual size_t GetCiphertextSize(size_t plaintext_size) const override;
+ virtual base::StringPiece GetKey() const override;
+ virtual base::StringPiece GetNoncePrefix() const override;
private:
size_t GetHashLength() const;
diff --git a/net/quic/crypto/p256_key_exchange.h b/net/quic/crypto/p256_key_exchange.h
index ce5a0d4..36ba296 100644
--- a/net/quic/crypto/p256_key_exchange.h
+++ b/net/quic/crypto/p256_key_exchange.h
@@ -38,11 +38,11 @@
static std::string NewPrivateKey();
// KeyExchange interface.
- virtual KeyExchange* NewKeyPair(QuicRandom* rand) const OVERRIDE;
+ virtual KeyExchange* NewKeyPair(QuicRandom* rand) const override;
virtual bool CalculateSharedKey(const base::StringPiece& peer_public_value,
- std::string* shared_key) const OVERRIDE;
- virtual base::StringPiece public_value() const OVERRIDE;
- virtual QuicTag tag() const OVERRIDE;
+ std::string* shared_key) const override;
+ virtual base::StringPiece public_value() const override;
+ virtual QuicTag tag() const override;
private:
enum {
diff --git a/net/quic/crypto/proof_source_chromium.h b/net/quic/crypto/proof_source_chromium.h
index 70ab92d..3d1849e 100644
--- a/net/quic/crypto/proof_source_chromium.h
+++ b/net/quic/crypto/proof_source_chromium.h
@@ -27,7 +27,7 @@
const std::string& server_config,
bool ecdsa_ok,
const std::vector<std::string>** out_certs,
- std::string* out_signature) OVERRIDE;
+ std::string* out_signature) override;
private:
DISALLOW_COPY_AND_ASSIGN(ProofSourceChromium);
diff --git a/net/quic/crypto/proof_test.cc b/net/quic/crypto/proof_test.cc
index 031cba2..0dde97c 100644
--- a/net/quic/crypto/proof_test.cc
+++ b/net/quic/crypto/proof_test.cc
@@ -40,7 +40,7 @@
virtual void Run(bool ok,
const string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) OVERRIDE {
+ scoped_ptr<ProofVerifyDetails>* details) override {
*ok_ = ok;
*error_details_ = error_details;
diff --git a/net/quic/crypto/proof_verifier_chromium.h b/net/quic/crypto/proof_verifier_chromium.h
index 7b305e2..057cc16 100644
--- a/net/quic/crypto/proof_verifier_chromium.h
+++ b/net/quic/crypto/proof_verifier_chromium.h
@@ -30,7 +30,7 @@
public:
// ProofVerifyDetails implementation
- virtual ProofVerifyDetails* Clone() const OVERRIDE;
+ virtual ProofVerifyDetails* Clone() const override;
CertVerifyResult cert_verify_result;
@@ -67,7 +67,7 @@
const ProofVerifyContext* verify_context,
std::string* error_details,
scoped_ptr<ProofVerifyDetails>* verify_details,
- ProofVerifierCallback* callback) OVERRIDE;
+ ProofVerifierCallback* callback) override;
private:
class Job;
diff --git a/net/quic/crypto/quic_crypto_client_config.cc b/net/quic/crypto/quic_crypto_client_config.cc
index 90dc265..1f668af 100644
--- a/net/quic/crypto/quic_crypto_client_config.cc
+++ b/net/quic/crypto/quic_crypto_client_config.cc
@@ -56,7 +56,9 @@
} // namespace
QuicCryptoClientConfig::QuicCryptoClientConfig()
- : disable_ecdsa_(false) {}
+ : disable_ecdsa_(false) {
+ SetDefaults();
+}
QuicCryptoClientConfig::~QuicCryptoClientConfig() {
STLDeleteValues(&cached_states_);
diff --git a/net/quic/crypto/quic_crypto_client_config.h b/net/quic/crypto/quic_crypto_client_config.h
index 39c2508..9fc8ff0 100644
--- a/net/quic/crypto/quic_crypto_client_config.h
+++ b/net/quic/crypto/quic_crypto_client_config.h
@@ -133,9 +133,6 @@
QuicCryptoClientConfig();
~QuicCryptoClientConfig();
- // Sets the members to reasonable, default values.
- void SetDefaults();
-
// LookupOrCreate returns a CachedState for the given |server_id|. If no such
// CachedState currently exists, it will be created and cached.
CachedState* LookupOrCreate(const QuicServerId& server_id);
@@ -269,6 +266,9 @@
private:
typedef std::map<QuicServerId, CachedState*> CachedStateMap;
+ // Sets the members to reasonable, default values.
+ void SetDefaults();
+
// CacheNewServerConfig checks for SCFG, STK, PROF, and CRT tags in |message|,
// verifies them, and stores them in the cached state if they validate.
// This is used on receipt of a REJ from a server, or when a server sends
diff --git a/net/quic/crypto/quic_crypto_client_config_test.cc b/net/quic/crypto/quic_crypto_client_config_test.cc
index b02243b..d2c4920 100644
--- a/net/quic/crypto/quic_crypto_client_config_test.cc
+++ b/net/quic/crypto/quic_crypto_client_config_test.cc
@@ -21,7 +21,7 @@
virtual ~TestProofVerifyDetails() {}
// ProofVerifyDetails implementation
- virtual ProofVerifyDetails* Clone() const OVERRIDE {
+ virtual ProofVerifyDetails* Clone() const override {
return new TestProofVerifyDetails;
}
};
@@ -81,7 +81,6 @@
TEST(QuicCryptoClientConfigTest, PreferAesGcm) {
QuicCryptoClientConfig config;
- config.SetDefaults();
if (config.aead.size() > 1)
EXPECT_NE(kAESG, config.aead[0]);
config.PreferAesGcm();
diff --git a/net/quic/crypto/quic_crypto_server_config.cc b/net/quic/crypto/quic_crypto_server_config.cc
index 6281043..d5a2b75 100644
--- a/net/quic/crypto/quic_crypto_server_config.cc
+++ b/net/quic/crypto/quic_crypto_server_config.cc
@@ -18,6 +18,7 @@
#include "net/quic/crypto/chacha20_poly1305_encrypter.h"
#include "net/quic/crypto/channel_id.h"
#include "net/quic/crypto/crypto_framer.h"
+#include "net/quic/crypto/crypto_handshake_message.h"
#include "net/quic/crypto/crypto_server_config_protobuf.h"
#include "net/quic/crypto/crypto_utils.h"
#include "net/quic/crypto/curve25519_key_exchange.h"
@@ -61,49 +62,6 @@
} // namespace
-// ClientHelloInfo contains information about a client hello message that is
-// only kept for as long as it's being processed.
-struct ClientHelloInfo {
- ClientHelloInfo(const IPEndPoint& in_client_ip, QuicWallTime in_now)
- : client_ip(in_client_ip),
- now(in_now),
- valid_source_address_token(false),
- client_nonce_well_formed(false),
- unique(false) {}
-
- // Inputs to EvaluateClientHello.
- const IPEndPoint client_ip;
- const QuicWallTime now;
-
- // Outputs from EvaluateClientHello.
- bool valid_source_address_token;
- bool client_nonce_well_formed;
- bool unique;
- StringPiece sni;
- StringPiece client_nonce;
- StringPiece server_nonce;
- StringPiece user_agent_id;
-
- // Errors from EvaluateClientHello.
- vector<uint32> reject_reasons;
- COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
-};
-
-struct ValidateClientHelloResultCallback::Result {
- Result(const CryptoHandshakeMessage& in_client_hello,
- IPEndPoint in_client_ip,
- QuicWallTime in_now)
- : client_hello(in_client_hello),
- info(in_client_ip, in_now),
- error_code(QUIC_NO_ERROR) {
- }
-
- CryptoHandshakeMessage client_hello;
- ClientHelloInfo info;
- QuicErrorCode error_code;
- string error_details;
-};
-
class ValidateClientHelloHelper {
public:
ValidateClientHelloHelper(ValidateClientHelloResultCallback::Result* result,
@@ -150,7 +108,7 @@
protected:
virtual void RunImpl(bool nonce_is_valid_and_unique,
- InsertStatus nonce_error) OVERRIDE {
+ InsertStatus nonce_error) override {
DVLOG(1) << "Using client nonce, unique: " << nonce_is_valid_and_unique
<< " nonce_error: " << nonce_error;
result_->info.unique = nonce_is_valid_and_unique;
@@ -199,12 +157,36 @@
// static
const char QuicCryptoServerConfig::TESTING[] = "secret string for testing";
+ClientHelloInfo::ClientHelloInfo(const IPEndPoint& in_client_ip,
+ QuicWallTime in_now)
+ : client_ip(in_client_ip),
+ now(in_now),
+ valid_source_address_token(false),
+ client_nonce_well_formed(false),
+ unique(false) {
+}
+
+ClientHelloInfo::~ClientHelloInfo() {
+}
+
PrimaryConfigChangedCallback::PrimaryConfigChangedCallback() {
}
PrimaryConfigChangedCallback::~PrimaryConfigChangedCallback() {
}
+ValidateClientHelloResultCallback::Result::Result(
+ const CryptoHandshakeMessage& in_client_hello,
+ IPEndPoint in_client_ip,
+ QuicWallTime in_now)
+ : client_hello(in_client_hello),
+ info(in_client_ip, in_now),
+ error_code(QUIC_NO_ERROR) {
+}
+
+ValidateClientHelloResultCallback::Result::~Result() {
+}
+
ValidateClientHelloResultCallback::ValidateClientHelloResultCallback() {
}
@@ -603,8 +585,9 @@
!info.client_nonce_well_formed ||
!info.unique ||
!requested_config.get()) {
- BuildRejection(
- *primary_config.get(), client_hello, info, rand, params, out);
+ BuildRejection(*primary_config.get(), client_hello, info,
+ validate_chlo_result.cached_network_params, rand, params,
+ out);
return QUIC_NO_ERROR;
}
@@ -773,13 +756,12 @@
(QuicVersionToQuicTag(supported_versions[i]));
}
out->SetVector(kVER, supported_version_tags);
- out->SetStringPiece(
- kSourceAddressTokenTag,
- NewSourceAddressToken(*requested_config.get(),
- client_address,
- rand,
- info.now,
- nullptr));
+ out->SetStringPiece(kSourceAddressTokenTag,
+ NewSourceAddressToken(*requested_config.get(),
+ client_address,
+ rand,
+ info.now,
+ nullptr));
QuicSocketAddressCoder address_coder(client_address);
out->SetStringPiece(kCADR, address_coder.Encode());
out->SetStringPiece(kPUBS, forward_secure_public_value);
@@ -949,8 +931,12 @@
HandshakeFailureReason source_address_token_error;
StringPiece srct;
if (client_hello.GetStringPiece(kSourceAddressTokenTag, &srct)) {
- source_address_token_error = ValidateSourceAddressToken(
- *requested_config.get(), srct, info->client_ip, info->now);
+ source_address_token_error =
+ ValidateSourceAddressToken(*requested_config.get(),
+ srct,
+ info->client_ip,
+ info->now,
+ &client_hello_state->cached_network_params);
info->valid_source_address_token =
(source_address_token_error == HANDSHAKE_OK);
} else {
@@ -1083,6 +1069,7 @@
const Config& config,
const CryptoHandshakeMessage& client_hello,
const ClientHelloInfo& info,
+ const CachedNetworkParameters& cached_network_params,
QuicRandom* rand,
QuicCryptoNegotiatedParameters *params,
CryptoHandshakeMessage* out) const {
@@ -1094,7 +1081,7 @@
info.client_ip,
rand,
info.now,
- nullptr));
+ &cached_network_params));
if (replay_protection_) {
out->SetStringPiece(kServerNonceTag, NewServerNonce(rand, info.now));
}
@@ -1437,7 +1424,8 @@
const Config& config,
StringPiece token,
const IPEndPoint& ip,
- QuicWallTime now) const {
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) const {
string storage;
StringPiece plaintext;
if (!config.source_address_token_boxer->Unbox(token, &storage, &plaintext)) {
@@ -1473,6 +1461,11 @@
return SOURCE_ADDRESS_TOKEN_EXPIRED_FAILURE;
}
+ if (FLAGS_quic_store_cached_network_params_from_chlo &&
+ source_address_token.has_cached_network_parameters()) {
+ *cached_network_params = source_address_token.cached_network_parameters();
+ }
+
return HANDSHAKE_OK;
}
diff --git a/net/quic/crypto/quic_crypto_server_config.h b/net/quic/crypto/quic_crypto_server_config.h
index ef8f6e9..30e0f6d 100644
--- a/net/quic/crypto/quic_crypto_server_config.h
+++ b/net/quic/crypto/quic_crypto_server_config.h
@@ -36,7 +36,29 @@
class StrikeRegister;
class StrikeRegisterClient;
-struct ClientHelloInfo;
+// ClientHelloInfo contains information about a client hello message that is
+// only kept for as long as it's being processed.
+struct ClientHelloInfo {
+ ClientHelloInfo(const IPEndPoint& in_client_ip, QuicWallTime in_now);
+ ~ClientHelloInfo();
+
+ // Inputs to EvaluateClientHello.
+ const IPEndPoint client_ip;
+ const QuicWallTime now;
+
+ // Outputs from EvaluateClientHello.
+ bool valid_source_address_token;
+ bool client_nonce_well_formed;
+ bool unique;
+ base::StringPiece sni;
+ base::StringPiece client_nonce;
+ base::StringPiece server_nonce;
+ base::StringPiece user_agent_id;
+
+ // Errors from EvaluateClientHello.
+ std::vector<uint32> reject_reasons;
+ COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
+};
namespace test {
class QuicCryptoServerConfigPeer;
@@ -58,7 +80,20 @@
public:
// Opaque token that holds information about the client_hello and
// its validity. Can be interpreted by calling ProcessClientHello.
- struct Result;
+ struct Result {
+ Result(const CryptoHandshakeMessage& in_client_hello,
+ IPEndPoint in_client_ip,
+ QuicWallTime in_now);
+ ~Result();
+
+ CryptoHandshakeMessage client_hello;
+ ClientHelloInfo info;
+ QuicErrorCode error_code;
+ std::string error_details;
+
+ // Populated if the CHLO STK contained a CachedNetworkParameters proto.
+ CachedNetworkParameters cached_network_params;
+ };
ValidateClientHelloResultCallback();
virtual ~ValidateClientHelloResultCallback();
@@ -386,6 +421,7 @@
const Config& config,
const CryptoHandshakeMessage& client_hello,
const ClientHelloInfo& info,
+ const CachedNetworkParameters& cached_network_params,
QuicRandom* rand,
QuicCryptoNegotiatedParameters *params,
CryptoHandshakeMessage* out) const;
@@ -407,10 +443,14 @@
// ValidateSourceAddressToken returns HANDSHAKE_OK if the source address token
// in |token| is a valid and timely token for the IP address |ip| given that
// the current time is |now|. Otherwise it returns the reason for failure.
- HandshakeFailureReason ValidateSourceAddressToken(const Config& config,
- base::StringPiece token,
- const IPEndPoint& ip,
- QuicWallTime now) const;
+ // |cached_network_params| is populated if |token| contains a
+ // CachedNetworkParameters proto.
+ HandshakeFailureReason ValidateSourceAddressToken(
+ const Config& config,
+ base::StringPiece token,
+ const IPEndPoint& ip,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) const;
// NewServerNonce generates and encrypts a random nonce.
std::string NewServerNonce(QuicRandom* rand, QuicWallTime now) const;
diff --git a/net/quic/crypto/quic_crypto_server_config_test.cc b/net/quic/crypto/quic_crypto_server_config_test.cc
index f44dc5c..59d6cf4 100644
--- a/net/quic/crypto/quic_crypto_server_config_test.cc
+++ b/net/quic/crypto/quic_crypto_server_config_test.cc
@@ -13,6 +13,7 @@
#include "net/quic/crypto/crypto_server_config_protobuf.h"
#include "net/quic/crypto/quic_random.h"
#include "net/quic/crypto/strike_register_client.h"
+#include "net/quic/quic_flags.h"
#include "net/quic/quic_time.h"
#include "net/quic/test_tools/mock_clock.h"
#include "net/quic/test_tools/quic_test_utils.h"
@@ -52,19 +53,37 @@
string NewSourceAddressToken(
string config_id,
- IPEndPoint ip,
+ const IPEndPoint& ip,
QuicRandom* rand,
QuicWallTime now) {
+ return NewSourceAddressToken(config_id, ip, rand, now, NULL);
+ }
+
+ string NewSourceAddressToken(
+ string config_id,
+ const IPEndPoint& ip,
+ QuicRandom* rand,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) {
return server_config_->NewSourceAddressToken(
- *GetConfig(config_id), ip, rand, now, nullptr);
+ *GetConfig(config_id), ip, rand, now, cached_network_params);
}
HandshakeFailureReason ValidateSourceAddressToken(string config_id,
StringPiece srct,
- IPEndPoint ip,
+ const IPEndPoint& ip,
QuicWallTime now) {
+ return ValidateSourceAddressToken(config_id, srct, ip, now, NULL);
+ }
+
+ HandshakeFailureReason ValidateSourceAddressToken(
+ string config_id,
+ StringPiece srct,
+ const IPEndPoint& ip,
+ QuicWallTime now,
+ CachedNetworkParameters* cached_network_params) {
return server_config_->ValidateSourceAddressToken(
- *GetConfig(config_id), srct, ip, now);
+ *GetConfig(config_id), srct, ip, now, cached_network_params);
}
string NewServerNonce(QuicRandom* rand, QuicWallTime now) const {
@@ -188,7 +207,7 @@
is_known_orbit_called_(false) {
}
- virtual bool IsKnownOrbit(StringPiece orbit) const OVERRIDE {
+ virtual bool IsKnownOrbit(StringPiece orbit) const override {
// Ensure that the strike register client lock is not held.
QuicCryptoServerConfigPeer peer(config_);
base::Lock* m = peer.GetStrikeRegisterClientLock();
@@ -204,7 +223,7 @@
virtual void VerifyNonceIsValidAndUnique(
StringPiece nonce,
QuicWallTime now,
- ResultCallback* cb) OVERRIDE {
+ ResultCallback* cb) override {
LOG(FATAL) << "Not implemented";
}
@@ -241,6 +260,8 @@
}
TEST(QuicCryptoServerConfigTest, SourceAddressTokens) {
+ ValueRestore<bool> old_flag(&FLAGS_quic_store_cached_network_params_from_chlo,
+ true);
const string kPrimary = "<primary>";
const string kOverride = "Config with custom source address token key";
@@ -329,6 +350,21 @@
now = original_time.Subtract(QuicTime::Delta::FromSeconds(3600 * 2));
DCHECK_EQ(SOURCE_ADDRESS_TOKEN_CLOCK_SKEW_FAILURE,
peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
+
+ // Make sure that if the source address token contains CachedNetworkParameters
+ // that this gets written to ValidateSourceAddressToken output argument.
+ CachedNetworkParameters cached_network_params_input;
+ cached_network_params_input.set_bandwidth_estimate_bytes_per_second(1234);
+ const string token4_with_cached_network_params = peer.NewSourceAddressToken(
+ kPrimary, ip4, rand, now, &cached_network_params_input);
+
+ CachedNetworkParameters cached_network_params_output;
+ EXPECT_NE(cached_network_params_output, cached_network_params_input);
+ peer.ValidateSourceAddressToken(kPrimary, token4_with_cached_network_params,
+ ip4, now, &cached_network_params_output);
+ // TODO(rtenneti): For server, enable the following check after serialization
+ // of optional CachedNetworkParameters is implemented.
+ // EXPECT_EQ(cached_network_params_output, cached_network_params_input);
}
TEST(QuicCryptoServerConfigTest, ValidateServerNonce) {
diff --git a/net/quic/crypto/quic_random.cc b/net/quic/crypto/quic_random.cc
index 6f46013..bc85c2d 100644
--- a/net/quic/crypto/quic_random.cc
+++ b/net/quic/crypto/quic_random.cc
@@ -17,10 +17,10 @@
static DefaultRandom* GetInstance();
// QuicRandom implementation
- virtual void RandBytes(void* data, size_t len) OVERRIDE;
- virtual uint64 RandUint64() OVERRIDE;
+ virtual void RandBytes(void* data, size_t len) override;
+ virtual uint64 RandUint64() override;
virtual void Reseed(const void* additional_entropy,
- size_t entropy_len) OVERRIDE;
+ size_t entropy_len) override;
private:
DefaultRandom() {};
diff --git a/net/quic/crypto/source_address_token.cc b/net/quic/crypto/source_address_token.cc
index f20c343..7ac43f0 100644
--- a/net/quic/crypto/source_address_token.cc
+++ b/net/quic/crypto/source_address_token.cc
@@ -14,13 +14,39 @@
namespace net {
-CachedNetworkParameters::CachedNetworkParameters() {
+CachedNetworkParameters::CachedNetworkParameters()
+ : bandwidth_estimate_bytes_per_second_(0),
+ max_bandwidth_estimate_bytes_per_second_(0),
+ max_bandwidth_timestamp_seconds_(0),
+ min_rtt_ms_(0),
+ previous_connection_state_(0),
+ timestamp_(0) {
}
CachedNetworkParameters::~CachedNetworkParameters() {
}
-SourceAddressToken::SourceAddressToken() {
+bool CachedNetworkParameters::operator==(
+ const CachedNetworkParameters& other) const {
+ return serving_region_ == other.serving_region_ &&
+ bandwidth_estimate_bytes_per_second_ ==
+ other.bandwidth_estimate_bytes_per_second_ &&
+ max_bandwidth_estimate_bytes_per_second_ ==
+ other.max_bandwidth_estimate_bytes_per_second_ &&
+ max_bandwidth_timestamp_seconds_ ==
+ other.max_bandwidth_timestamp_seconds_ &&
+ min_rtt_ms_ == other.min_rtt_ms_ &&
+ previous_connection_state_ == other.previous_connection_state_ &&
+ timestamp_ == other.timestamp_;
+}
+
+bool CachedNetworkParameters::operator!=(
+ const CachedNetworkParameters& other) const {
+ return !(*this == other);
+}
+
+SourceAddressToken::SourceAddressToken()
+ : has_cached_network_parameters_(false) {
}
SourceAddressToken::~SourceAddressToken() {
diff --git a/net/quic/crypto/source_address_token.h b/net/quic/crypto/source_address_token.h
index 1101351..76c3454 100644
--- a/net/quic/crypto/source_address_token.h
+++ b/net/quic/crypto/source_address_token.h
@@ -28,6 +28,9 @@
CachedNetworkParameters();
~CachedNetworkParameters();
+ bool operator==(const CachedNetworkParameters& other) const;
+ bool operator!=(const CachedNetworkParameters& other) const;
+
std::string serving_region() const {
return serving_region_;
}
@@ -133,6 +136,10 @@
void set_cached_network_parameters(
const CachedNetworkParameters& cached_network_parameters) {
cached_network_parameters_ = cached_network_parameters;
+ has_cached_network_parameters_ = true;
+ }
+ bool has_cached_network_parameters() const {
+ return has_cached_network_parameters_;
}
private:
@@ -146,6 +153,9 @@
// The server can provide estimated network parameters to be used for
// initial parameter selection in future connections.
CachedNetworkParameters cached_network_parameters_;
+ // TODO(rtenneti): Delete |has_cached_network_parameters_| after we convert
+ // SourceAddressToken to protobuf.
+ bool has_cached_network_parameters_;
DISALLOW_COPY_AND_ASSIGN(SourceAddressToken);
};
diff --git a/net/quic/quic_ack_notifier_manager.h b/net/quic/quic_ack_notifier_manager.h
index bf5b345..122bda1 100644
--- a/net/quic/quic_ack_notifier_manager.h
+++ b/net/quic/quic_ack_notifier_manager.h
@@ -10,17 +10,6 @@
#include "base/containers/hash_tables.h"
#include "net/quic/quic_protocol.h"
-#if defined(COMPILER_GCC)
-namespace BASE_HASH_NAMESPACE {
-template<>
-struct hash<net::QuicAckNotifier*> {
- std::size_t operator()(const net::QuicAckNotifier* ptr) const {
- return hash<size_t>()(reinterpret_cast<size_t>(ptr));
- }
-};
-}
-#endif
-
namespace net {
class QuicAckNotifier;
diff --git a/net/quic/quic_alarm_test.cc b/net/quic/quic_alarm_test.cc
index 434bb38..47e23e3 100644
--- a/net/quic/quic_alarm_test.cc
+++ b/net/quic/quic_alarm_test.cc
@@ -32,12 +32,12 @@
}
protected:
- virtual void SetImpl() OVERRIDE {
+ virtual void SetImpl() override {
DCHECK(deadline().IsInitialized());
scheduled_ = true;
}
- virtual void CancelImpl() OVERRIDE {
+ virtual void CancelImpl() override {
DCHECK(!deadline().IsInitialized());
scheduled_ = false;
}
diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc
index 5454c10..b7e8185 100644
--- a/net/quic/quic_client_session.cc
+++ b/net/quic/quic_client_session.cc
@@ -153,7 +153,7 @@
num_total_streams_(0),
task_runner_(task_runner),
net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
- logger_(new QuicConnectionLogger(net_log_)),
+ logger_(new QuicConnectionLogger(this, net_log_)),
num_packets_read_(0),
going_away_(false),
weak_factory_(this) {
@@ -265,14 +265,14 @@
const QuicConnectionStats stats = connection()->GetStats();
if (stats.max_sequence_reordering == 0)
return;
- const uint64 kMaxReordering = 100;
- uint64 reordering = kMaxReordering;
- if (stats.min_rtt_us > 0 ) {
- reordering =
- GG_UINT64_C(100) * stats.max_time_reordering_us / stats.min_rtt_us;
+ const base::HistogramBase::Sample kMaxReordering = 100;
+ base::HistogramBase::Sample reordering = kMaxReordering;
+ if (stats.min_rtt_us > 0) {
+ reordering = static_cast<base::HistogramBase::Sample>(
+ 100 * stats.max_time_reordering_us / stats.min_rtt_us);
}
UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTime",
- reordering, 0, kMaxReordering, 50);
+ reordering, 0, kMaxReordering, 50);
if (stats.min_rtt_us > 100 * 1000) {
UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTimeLongRtt",
reordering, 0, kMaxReordering, 50);
diff --git a/net/quic/quic_client_session.h b/net/quic/quic_client_session.h
index fa712c2..430ef52 100644
--- a/net/quic/quic_client_session.h
+++ b/net/quic/quic_client_session.h
@@ -124,30 +124,30 @@
// QuicSession methods:
virtual void OnStreamFrames(
- const std::vector<QuicStreamFrame>& frames) OVERRIDE;
- virtual QuicReliableClientStream* CreateOutgoingDataStream() OVERRIDE;
- virtual QuicCryptoClientStream* GetCryptoStream() OVERRIDE;
- virtual void CloseStream(QuicStreamId stream_id) OVERRIDE;
+ const std::vector<QuicStreamFrame>& frames) override;
+ virtual QuicReliableClientStream* CreateOutgoingDataStream() override;
+ virtual QuicCryptoClientStream* GetCryptoStream() override;
+ virtual void CloseStream(QuicStreamId stream_id) override;
virtual void SendRstStream(QuicStreamId id,
QuicRstStreamErrorCode error,
- QuicStreamOffset bytes_written) OVERRIDE;
- virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) OVERRIDE;
+ QuicStreamOffset bytes_written) override;
+ virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
virtual void OnCryptoHandshakeMessageSent(
- const CryptoHandshakeMessage& message) OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
virtual void OnCryptoHandshakeMessageReceived(
- const CryptoHandshakeMessage& message) OVERRIDE;
- virtual bool GetSSLInfo(SSLInfo* ssl_info) const OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
+ virtual bool GetSSLInfo(SSLInfo* ssl_info) const override;
// QuicClientSessionBase methods:
virtual void OnProofValid(
- const QuicCryptoClientConfig::CachedState& cached) OVERRIDE;
+ const QuicCryptoClientConfig::CachedState& cached) override;
virtual void OnProofVerifyDetailsAvailable(
- const ProofVerifyDetails& verify_details) OVERRIDE;
+ const ProofVerifyDetails& verify_details) override;
// QuicConnectionVisitorInterface methods:
- virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
+ virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
virtual void OnSuccessfulVersionNegotiation(
- const QuicVersion& version) OVERRIDE;
+ const QuicVersion& version) override;
// Performs a crypto handshake with the server.
int CryptoConnect(bool require_confirmation,
@@ -182,7 +182,7 @@
protected:
// QuicSession methods:
- virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
+ virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
private:
friend class test::QuicClientSessionPeer;
diff --git a/net/quic/quic_client_session_base.h b/net/quic/quic_client_session_base.h
index 834d006..ae0644e 100644
--- a/net/quic/quic_client_session_base.h
+++ b/net/quic/quic_client_session_base.h
@@ -33,7 +33,7 @@
const ProofVerifyDetails& verify_details) = 0;
// Override base class to set FEC policy before any data is sent by client.
- virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) OVERRIDE;
+ virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
private:
DISALLOW_COPY_AND_ASSIGN(QuicClientSessionBase);
diff --git a/net/quic/quic_client_session_test.cc b/net/quic/quic_client_session_test.cc
index 9758ed4..b1cfe3d 100644
--- a/net/quic/quic_client_session_test.cc
+++ b/net/quic/quic_client_session_test.cc
@@ -51,11 +51,9 @@
session_.InitializeSession(QuicServerId(kServerHostname, kServerPort, false,
PRIVACY_MODE_DISABLED),
&crypto_config_, nullptr);
- session_.config()->SetDefaults();
- crypto_config_.SetDefaults();
}
- virtual void TearDown() OVERRIDE {
+ virtual void TearDown() override {
session_.CloseSessionOnError(ERR_ABORTED);
}
diff --git a/net/quic/quic_config.cc b/net/quic/quic_config.cc
index 5330b7c..7b7976c 100644
--- a/net/quic/quic_config.cc
+++ b/net/quic/quic_config.cc
@@ -427,6 +427,7 @@
QuicConfig::QuicConfig()
: max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
max_idle_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
+ max_undecryptable_packets_(0),
congestion_feedback_(kCGST, PRESENCE_REQUIRED),
connection_options_(kCOPT, PRESENCE_OPTIONAL),
idle_connection_state_lifetime_seconds_(kICSL, PRESENCE_REQUIRED),
@@ -443,6 +444,7 @@
// QUIC_VERSION_19.
initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
socket_receive_buffer_(kSRBF, PRESENCE_OPTIONAL) {
+ SetDefaults();
}
QuicConfig::~QuicConfig() {}
@@ -643,6 +645,7 @@
QuicTime::Delta::FromSeconds(kMaxTimeForCryptoHandshakeSecs);
max_idle_time_before_crypto_handshake_ =
QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs);
+ max_undecryptable_packets_ = kDefaultMaxUndecryptablePackets;
SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
diff --git a/net/quic/quic_config.h b/net/quic/quic_config.h
index 203eb2e..7be4569 100644
--- a/net/quic/quic_config.h
+++ b/net/quic/quic_config.h
@@ -89,7 +89,7 @@
// Serialises |name_| and value to |out|. If |negotiated_| is true then
// |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
- virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+ virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
// Sets |negotiated_value_| to the minimum of |max_value_| and the
// corresponding value from |peer_hello|. If the corresponding value is
@@ -98,7 +98,7 @@
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- std::string* error_details) OVERRIDE;
+ std::string* error_details) override;
private:
uint32 max_value_;
@@ -123,7 +123,7 @@
// Serialises |name_| and vector (either possible or negotiated) to |out|. If
// |negotiated_| is true then |negotiated_tag_| is serialised, otherwise
// |possible_values_| is serialised.
- virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+ virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
// Selects the tag common to both tags in |client_hello| for |name_| and
// |possible_values_| with preference to tag in |possible_values_|. The
@@ -131,7 +131,7 @@
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- std::string* error_details) OVERRIDE;
+ std::string* error_details) override;
private:
// Reads the vector corresponding to |name_| from |msg| into |out|. If the
@@ -166,13 +166,13 @@
void SetReceivedValue(uint32 value);
// If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
- virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+ virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
// Sets |value_| to the corresponding value from |peer_hello_| if it exists.
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- std::string* error_details) OVERRIDE;
+ std::string* error_details) override;
private:
uint32 send_value_;
@@ -200,13 +200,13 @@
void SetReceivedValue(QuicTag value);
// If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
- virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+ virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
// Sets |value_| to the corresponding value from |client_hello_| if it exists.
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- std::string* error_details) OVERRIDE;
+ std::string* error_details) override;
private:
QuicTag send_value_;
@@ -235,14 +235,14 @@
// If has_send_value is true, serialises |tag_vector_| and |send_value_| to
// |out|.
- virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+ virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
// Sets |receive_values_| to the corresponding value from |client_hello_| if
// it exists.
virtual QuicErrorCode ProcessPeerHello(
const CryptoHandshakeMessage& peer_hello,
HelloType hello_type,
- std::string* error_details) OVERRIDE;
+ std::string* error_details) override;
private:
QuicTagVector send_values_;
@@ -304,6 +304,14 @@
return max_idle_time_before_crypto_handshake_;
}
+ void set_max_undecryptable_packets(size_t max_undecryptable_packets) {
+ max_undecryptable_packets_ = max_undecryptable_packets;
+ }
+
+ size_t max_undecryptable_packets() const {
+ return max_undecryptable_packets_;
+ }
+
// Sets the peer's default initial congestion window in packets.
void SetInitialCongestionWindowToSend(size_t initial_window);
@@ -362,9 +370,6 @@
bool negotiated() const;
- // SetDefaults sets the members to sensible, default values.
- void SetDefaults();
-
// ToHandshakeMessage serialises the settings in this object as a series of
// tags /value pairs and adds them to |out|.
void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
@@ -378,11 +383,16 @@
private:
friend class test::QuicConfigPeer;
+ // SetDefaults sets the members to sensible, default values.
+ void SetDefaults();
+
// Configurations options that are not negotiated.
// Maximum time the session can be alive before crypto handshake is finished.
QuicTime::Delta max_time_before_crypto_handshake_;
// Maximum idle time before the crypto handshake has completed.
QuicTime::Delta max_idle_time_before_crypto_handshake_;
+ // Maximum number of undecryptable packets stored before CHLO/SHLO.
+ size_t max_undecryptable_packets_;
// Congestion control feedback type.
QuicNegotiableTag congestion_feedback_;
diff --git a/net/quic/quic_config_test.cc b/net/quic/quic_config_test.cc
index 2263e44..914b137 100644
--- a/net/quic/quic_config_test.cc
+++ b/net/quic/quic_config_test.cc
@@ -22,15 +22,10 @@
class QuicConfigTest : public ::testing::Test {
protected:
- QuicConfigTest() {
- config_.SetDefaults();
- }
-
QuicConfig config_;
};
TEST_F(QuicConfigTest, ToHandshakeMessage) {
- config_.SetDefaults();
config_.SetInitialFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
config_.SetInitialStreamFlowControlWindowToSend(
@@ -265,7 +260,6 @@
TEST_F(QuicConfigTest, NoOverLapInCGST) {
QuicConfig server_config;
- server_config.SetDefaults();
QuicTagVector cgst;
cgst.push_back(kTBBR);
server_config.SetCongestionFeedback(cgst, kTBBR);
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 8d49010..f684cf2 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -6,6 +6,7 @@
#include <string.h>
#include <sys/types.h>
+
#include <algorithm>
#include <iterator>
#include <limits>
@@ -53,10 +54,6 @@
// that this becomes limiting, we can revisit.
const size_t kMaxFecGroups = 2;
-// Limit the number of undecryptable packets we buffer in
-// expectation of the CHLO/SHLO arriving.
-const size_t kMaxUndecryptablePackets = 10;
-
// Maximum number of acks received before sending an ack in response.
const size_t kMaxPacketsReceivedBeforeAckSend = 20;
@@ -72,7 +69,7 @@
: connection_(connection) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
connection_->SendAck();
return QuicTime::Zero();
}
@@ -92,7 +89,7 @@
: connection_(connection) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
connection_->OnRetransmissionTimeout();
return QuicTime::Zero();
}
@@ -111,7 +108,7 @@
: connection_(connection) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
connection_->WriteIfNotBlocked();
// Never reschedule the alarm, since CanWrite does that.
return QuicTime::Zero();
@@ -129,7 +126,7 @@
: connection_(connection) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
connection_->CheckForTimeout();
// Never reschedule the alarm, since CheckForTimeout does that.
return QuicTime::Zero();
@@ -147,7 +144,7 @@
: connection_(connection) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
connection_->SendPing();
return QuicTime::Zero();
}
@@ -162,10 +159,10 @@
QuicConnection::QueuedPacket::QueuedPacket(SerializedPacket packet,
EncryptionLevel level)
- : serialized_packet(packet),
- encryption_level(level),
- transmission_type(NOT_RETRANSMISSION),
- original_sequence_number(0) {
+ : serialized_packet(packet),
+ encryption_level(level),
+ transmission_type(NOT_RETRANSMISSION),
+ original_sequence_number(0) {
}
QuicConnection::QueuedPacket::QueuedPacket(
@@ -204,6 +201,7 @@
last_decrypted_packet_level_(ENCRYPTION_NONE),
largest_seen_packet_with_ack_(0),
largest_seen_packet_with_stop_waiting_(0),
+ max_undecryptable_packets_(0),
pending_version_negotiation_packet_(false),
received_packet_manager_(&stats_),
ack_queued_(false),
@@ -271,6 +269,7 @@
SetIdleNetworkTimeout(config.IdleConnectionStateLifetime());
}
sent_packet_manager_.SetFromConfig(config);
+ max_undecryptable_packets_ = config.max_undecryptable_packets();
}
bool QuicConnection::SelectMutualVersion(
@@ -1116,7 +1115,7 @@
// because the CHLO or SHLO packet was lost.
if (framer_.error() == QUIC_DECRYPTION_FAILURE) {
if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
- undecryptable_packets_.size() < kMaxUndecryptablePackets) {
+ undecryptable_packets_.size() < max_undecryptable_packets_) {
QueueUndecryptablePacket(packet);
} else if (debug_visitor_.get() != nullptr) {
debug_visitor_->OnUndecryptablePacket();
@@ -1176,8 +1175,7 @@
return;
}
- { // Limit the scope of the bundler.
- // Set |include_ack| to false in bundler; ack inclusion happens elsewhere.
+ { // Limit the scope of the bundler. ACK inclusion happens elsewhere.
ScopedPacketBundler bundler(this, NO_ACK);
visitor_->OnCanWrite();
}
@@ -1322,7 +1320,8 @@
// If the scheduler requires a delay, then we can not send this packet now.
if (!delay.IsZero()) {
send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
- DVLOG(1) << "Delaying sending.";
+ DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
+ << "ms";
return false;
}
send_alarm_->Cancel();
@@ -1408,15 +1407,6 @@
if (result.error_code == ERR_IO_PENDING) {
DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
}
- if (debug_visitor_.get() != nullptr) {
- // Pass the write result to the visitor.
- debug_visitor_->OnPacketSent(sequence_number,
- packet->original_sequence_number,
- packet->encryption_level,
- packet->transmission_type,
- *encrypted,
- result);
- }
if (result.status == WRITE_STATUS_BLOCKED) {
visitor_->OnWriteBlocked();
@@ -1429,6 +1419,15 @@
}
}
QuicTime now = clock_->Now();
+ if (result.status != WRITE_STATUS_ERROR && debug_visitor_.get() != nullptr) {
+ // Pass the write result to the visitor.
+ debug_visitor_->OnPacketSent(packet->serialized_packet,
+ packet->original_sequence_number,
+ packet->encryption_level,
+ packet->transmission_type,
+ *encrypted,
+ now);
+ }
if (packet->transmission_type == NOT_RETRANSMISSION) {
time_of_last_sent_new_packet_ = now;
}
@@ -1857,7 +1856,7 @@
// Adjust the idle timeout on client and server to prevent clients from
// sending requests to servers which have already closed the connection.
if (is_server_) {
- timeout = timeout.Add(QuicTime::Delta::FromSeconds(1));
+ timeout = timeout.Add(QuicTime::Delta::FromSeconds(3));
} else if (timeout > QuicTime::Delta::FromSeconds(1)) {
timeout = timeout.Subtract(QuicTime::Delta::FromSeconds(1));
}
@@ -1895,7 +1894,7 @@
// Adjust the idle timeout on client and server to prevent clients from
// sending requests to servers which have already closed the connection.
if (is_server_) {
- idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(1));
+ idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(3));
} else if (idle_timeout > QuicTime::Delta::FromSeconds(1)) {
idle_timeout = idle_timeout.Subtract(QuicTime::Delta::FromSeconds(1));
}
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 0b017b0..fa117f8 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -124,12 +124,12 @@
virtual ~QuicConnectionDebugVisitor() {}
// Called when a packet has been sent.
- virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number,
+ virtual void OnPacketSent(const SerializedPacket& serialized_packet,
QuicPacketSequenceNumber original_sequence_number,
EncryptionLevel level,
TransmissionType transmission_type,
const QuicEncryptedPacket& packet,
- WriteResult result) {}
+ QuicTime sent_time) {}
// Called when a packet has been received, but before it is
// validated or parsed.
@@ -299,7 +299,7 @@
virtual void SendConnectionCloseWithDetails(QuicErrorCode error,
const std::string& details);
// Notifies the visitor of the close and marks the connection as disconnected.
- virtual void CloseConnection(QuicErrorCode error, bool from_peer) OVERRIDE;
+ virtual void CloseConnection(QuicErrorCode error, bool from_peer) override;
virtual void SendGoAway(QuicErrorCode error,
QuicStreamId last_good_stream_id,
const std::string& reason);
@@ -317,7 +317,7 @@
// QuicBlockedWriterInterface
// Called when the underlying connection becomes writable to allow queued
// writes to happen.
- virtual void OnCanWrite() OVERRIDE;
+ virtual void OnCanWrite() override;
// Called when an error occurs while attempting to write a packet to the
// network.
@@ -335,47 +335,47 @@
}
// From QuicFramerVisitorInterface
- virtual void OnError(QuicFramer* framer) OVERRIDE;
- virtual bool OnProtocolVersionMismatch(QuicVersion received_version) OVERRIDE;
- virtual void OnPacket() OVERRIDE;
+ virtual void OnError(QuicFramer* framer) override;
+ virtual bool OnProtocolVersionMismatch(QuicVersion received_version) override;
+ virtual void OnPacket() override;
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& packet) OVERRIDE;
+ const QuicPublicResetPacket& packet) override;
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) OVERRIDE;
- virtual void OnRevivedPacket() OVERRIDE;
+ const QuicVersionNegotiationPacket& packet) override;
+ virtual void OnRevivedPacket() override;
virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) OVERRIDE;
- virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
- virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE;
- virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
- virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE;
- virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
- virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+ const QuicPacketPublicHeader& header) override;
+ virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
+ virtual void OnDecryptedPacket(EncryptionLevel level) override;
+ virtual bool OnPacketHeader(const QuicPacketHeader& header) override;
+ virtual void OnFecProtectedPayload(base::StringPiece payload) override;
+ virtual bool OnStreamFrame(const QuicStreamFrame& frame) override;
+ virtual bool OnAckFrame(const QuicAckFrame& frame) override;
virtual bool OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) OVERRIDE;
- virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE;
- virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+ const QuicCongestionFeedbackFrame& frame) override;
+ virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+ virtual bool OnPingFrame(const QuicPingFrame& frame) override;
+ virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) OVERRIDE;
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
- virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
- virtual void OnFecData(const QuicFecData& fec) OVERRIDE;
- virtual void OnPacketComplete() OVERRIDE;
+ const QuicConnectionCloseFrame& frame) override;
+ virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+ virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+ virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+ virtual void OnFecData(const QuicFecData& fec) override;
+ virtual void OnPacketComplete() override;
// QuicPacketGenerator::DelegateInterface
virtual bool ShouldGeneratePacket(TransmissionType transmission_type,
HasRetransmittableData retransmittable,
- IsHandshake handshake) OVERRIDE;
- virtual QuicAckFrame* CreateAckFrame() OVERRIDE;
- virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() OVERRIDE;
- virtual QuicStopWaitingFrame* CreateStopWaitingFrame() OVERRIDE;
- virtual void OnSerializedPacket(const SerializedPacket& packet) OVERRIDE;
+ IsHandshake handshake) override;
+ virtual QuicAckFrame* CreateAckFrame() override;
+ virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() override;
+ virtual QuicStopWaitingFrame* CreateStopWaitingFrame() override;
+ virtual void OnSerializedPacket(const SerializedPacket& packet) override;
// QuicSentPacketManager::NetworkChangeVisitor
virtual void OnCongestionWindowChange(
- QuicByteCount congestion_window) OVERRIDE;
+ QuicByteCount congestion_window) override;
// Called by the crypto stream when the handshake completes. In the server's
// case this is when the SHLO has been ACKed. Clients call this on receipt of
@@ -713,6 +713,9 @@
// sent with the INITIAL encryption and the CHLO message was lost.
std::deque<QuicEncryptedPacket*> undecryptable_packets_;
+ // Maximum number of undecryptable packets the connection will store.
+ size_t max_undecryptable_packets_;
+
// When the version negotiation packet could not be sent because the socket
// was not writable, this is set to true.
bool pending_version_negotiation_packet_;
diff --git a/net/quic/quic_connection_helper.cc b/net/quic/quic_connection_helper.cc
index fefd6fa..83c1648 100644
--- a/net/quic/quic_connection_helper.cc
+++ b/net/quic/quic_connection_helper.cc
@@ -29,7 +29,7 @@
weak_factory_(this) {}
protected:
- virtual void SetImpl() OVERRIDE {
+ virtual void SetImpl() override {
DCHECK(deadline().IsInitialized());
if (task_deadline_.IsInitialized()) {
if (task_deadline_ <= deadline()) {
@@ -54,7 +54,7 @@
task_deadline_ = deadline();
}
- virtual void CancelImpl() OVERRIDE {
+ virtual void CancelImpl() override {
DCHECK(!deadline().IsInitialized());
// Since tasks can not be un-posted, OnAlarm will be invoked which
// will notice that deadline is not Initialized and will do nothing.
diff --git a/net/quic/quic_connection_helper.h b/net/quic/quic_connection_helper.h
index 28cff52..e1754e5 100644
--- a/net/quic/quic_connection_helper.h
+++ b/net/quic/quic_connection_helper.h
@@ -37,9 +37,9 @@
virtual ~QuicConnectionHelper();
// QuicConnectionHelperInterface
- virtual const QuicClock* GetClock() const OVERRIDE;
- virtual QuicRandom* GetRandomGenerator() OVERRIDE;
- virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE;
+ virtual const QuicClock* GetClock() const override;
+ virtual QuicRandom* GetRandomGenerator() override;
+ virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
private:
base::TaskRunner* task_runner_;
diff --git a/net/quic/quic_connection_helper_test.cc b/net/quic/quic_connection_helper_test.cc
index 638ca46..8a2c931 100644
--- a/net/quic/quic_connection_helper_test.cc
+++ b/net/quic/quic_connection_helper_test.cc
@@ -17,7 +17,7 @@
public:
TestDelegate() : fired_(false) {}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
fired_ = true;
return QuicTime::Zero();
}
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc
index 4e40417..b5ca18b 100644
--- a/net/quic/quic_connection_logger.cc
+++ b/net/quic/quic_connection_logger.cc
@@ -46,24 +46,22 @@
}
base::Value* NetLogQuicPacketSentCallback(
- QuicPacketSequenceNumber sequence_number,
+ const SerializedPacket& serialized_packet,
QuicPacketSequenceNumber original_sequence_number,
EncryptionLevel level,
TransmissionType transmission_type,
size_t packet_size,
- WriteResult result,
+ QuicTime sent_time,
NetLog::LogLevel /* log_level */) {
base::DictionaryValue* dict = new base::DictionaryValue();
dict->SetInteger("encryption_level", level);
dict->SetInteger("transmission_type", transmission_type);
dict->SetString("packet_sequence_number",
- base::Uint64ToString(sequence_number));
+ base::Uint64ToString(serialized_packet.sequence_number));
dict->SetString("original_sequence_number",
base::Uint64ToString(original_sequence_number));
dict->SetInteger("size", packet_size);
- if (result.status != WRITE_STATUS_OK) {
- dict->SetInteger("net_error", result.error_code);
- }
+ dict->SetInteger("sent_time_us", sent_time.ToDebuggingValue());
return dict;
}
@@ -324,8 +322,10 @@
} // namespace
-QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
+QuicConnectionLogger::QuicConnectionLogger(QuicSession* session,
+ const BoundNetLog& net_log)
: net_log_(net_log),
+ session_(session),
last_received_packet_sequence_number_(0),
last_received_packet_size_(0),
largest_received_packet_sequence_number_(0),
@@ -454,6 +454,10 @@
frame.stop_waiting_frame));
break;
case PING_FRAME:
+ UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
+ session_->IsConnectionFlowControlBlocked());
+ UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
+ session_->IsStreamFlowControlBlocked());
// PingFrame has no contents to log, so just record that it was sent.
net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_SENT);
break;
@@ -463,17 +467,17 @@
}
void QuicConnectionLogger::OnPacketSent(
- QuicPacketSequenceNumber sequence_number,
+ const SerializedPacket& serialized_packet,
QuicPacketSequenceNumber original_sequence_number,
EncryptionLevel level,
TransmissionType transmission_type,
const QuicEncryptedPacket& packet,
- WriteResult result) {
+ QuicTime sent_time) {
net_log_.AddEvent(
NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
- base::Bind(&NetLogQuicPacketSentCallback, sequence_number,
+ base::Bind(&NetLogQuicPacketSentCallback, serialized_packet,
original_sequence_number, level, transmission_type,
- packet.length(), result));
+ packet.length(), sent_time));
}
void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
diff --git a/net/quic/quic_connection_logger.h b/net/quic/quic_connection_logger.h
index 7693d79..c714e3b 100644
--- a/net/quic/quic_connection_logger.h
+++ b/net/quic/quic_connection_logger.h
@@ -12,6 +12,7 @@
#include "net/base/network_change_notifier.h"
#include "net/quic/quic_connection.h"
#include "net/quic/quic_protocol.h"
+#include "net/quic/quic_session.h"
namespace net {
namespace test {
@@ -26,51 +27,51 @@
class NET_EXPORT_PRIVATE QuicConnectionLogger
: public QuicConnectionDebugVisitor {
public:
- explicit QuicConnectionLogger(const BoundNetLog& net_log);
+ QuicConnectionLogger(QuicSession* session, const BoundNetLog& net_log);
virtual ~QuicConnectionLogger();
// QuicPacketGenerator::DebugDelegateInterface
- virtual void OnFrameAddedToPacket(const QuicFrame& frame) OVERRIDE;
+ virtual void OnFrameAddedToPacket(const QuicFrame& frame) override;
// QuicConnectionDebugVisitorInterface
- virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number,
+ virtual void OnPacketSent(const SerializedPacket& serialized_packet,
QuicPacketSequenceNumber original_sequence_number,
EncryptionLevel level,
TransmissionType transmission_type,
const QuicEncryptedPacket& packet,
- WriteResult result) OVERRIDE;
+ QuicTime sent_time) override;
virtual void OnPacketReceived(const IPEndPoint& self_address,
const IPEndPoint& peer_address,
- const QuicEncryptedPacket& packet) OVERRIDE;
+ const QuicEncryptedPacket& packet) override;
virtual void OnIncorrectConnectionId(
- QuicConnectionId connection_id) OVERRIDE;
- virtual void OnUndecryptablePacket() OVERRIDE;
+ QuicConnectionId connection_id) override;
+ virtual void OnUndecryptablePacket() override;
virtual void OnDuplicatePacket(QuicPacketSequenceNumber sequence_number)
- OVERRIDE;
- virtual void OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
- virtual void OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
- virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
- virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+ override;
+ virtual void OnProtocolVersionMismatch(QuicVersion version) override;
+ virtual void OnPacketHeader(const QuicPacketHeader& header) override;
+ virtual void OnStreamFrame(const QuicStreamFrame& frame) override;
+ virtual void OnAckFrame(const QuicAckFrame& frame) override;
virtual void OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) OVERRIDE;
- virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE;
- virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+ const QuicCongestionFeedbackFrame& frame) override;
+ virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+ virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
virtual void OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) OVERRIDE;
- virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
- virtual void OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
- virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
- virtual void OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
+ const QuicConnectionCloseFrame& frame) override;
+ virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+ virtual void OnBlockedFrame(const QuicBlockedFrame& frame) override;
+ virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+ virtual void OnPingFrame(const QuicPingFrame& frame) override;
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& packet) OVERRIDE;
+ const QuicPublicResetPacket& packet) override;
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) OVERRIDE;
+ const QuicVersionNegotiationPacket& packet) override;
virtual void OnRevivedPacket(const QuicPacketHeader& revived_header,
- base::StringPiece payload) OVERRIDE;
- virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
+ base::StringPiece payload) override;
+ virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
virtual void OnSuccessfulVersionNegotiation(
- const QuicVersion& version) OVERRIDE;
+ const QuicVersion& version) override;
void OnCryptoHandshakeMessageReceived(
const CryptoHandshakeMessage& message);
@@ -119,6 +120,7 @@
void RecordLossHistograms() const;
BoundNetLog net_log_;
+ QuicSession* session_; // Unowned.
// The last packet sequence number received.
QuicPacketSequenceNumber last_received_packet_sequence_number_;
// The size of the most recently received packet.
diff --git a/net/quic/quic_connection_logger_unittest.cc b/net/quic/quic_connection_logger_unittest.cc
index 9f9cd9a..dbba7d7 100644
--- a/net/quic/quic_connection_logger_unittest.cc
+++ b/net/quic/quic_connection_logger_unittest.cc
@@ -19,7 +19,7 @@
class QuicConnectionLoggerTest : public ::testing::Test {
protected:
- QuicConnectionLoggerTest() : logger_(net_log_) {}
+ QuicConnectionLoggerTest() : logger_(nullptr, net_log_) {}
BoundNetLog net_log_;
QuicConnectionLogger logger_;
diff --git a/net/quic/quic_connection_stats.h b/net/quic/quic_connection_stats.h
index 1cb8ca7..c681dea 100644
--- a/net/quic/quic_connection_stats.h
+++ b/net/quic/quic_connection_stats.h
@@ -51,8 +51,8 @@
uint32 rto_count; // Count of times the rto timer fired.
uint32 spurious_rto_count;
- uint32 min_rtt_us; // Minimum RTT in microseconds.
- uint32 srtt_us; // Smoothed RTT in microseconds.
+ int64 min_rtt_us; // Minimum RTT in microseconds.
+ 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
@@ -64,7 +64,7 @@
// Maximum reordering observed in sequence space.
uint32 max_sequence_reordering;
// Maximum reordering observed in microseconds
- uint32 max_time_reordering_us;
+ int64 max_time_reordering_us;
// The following stats are used only in TcpCubicSender.
// The number of loss events from TCP's perspective. Each loss event includes
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 2869513..b084428 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -93,15 +93,15 @@
virtual ~TaggingEncrypter() {}
// QuicEncrypter interface.
- virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
- virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+ virtual bool SetKey(StringPiece key) override { return true; }
+ virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
return true;
}
virtual bool Encrypt(StringPiece nonce,
StringPiece associated_data,
StringPiece plaintext,
- unsigned char* output) OVERRIDE {
+ unsigned char* output) override {
memcpy(output, plaintext.data(), plaintext.size());
output += plaintext.size();
memset(output, tag_, kTagSize);
@@ -110,29 +110,29 @@
virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
StringPiece associated_data,
- StringPiece plaintext) OVERRIDE {
+ StringPiece plaintext) override {
const size_t len = plaintext.size() + kTagSize;
uint8* buffer = new uint8[len];
Encrypt(StringPiece(), associated_data, plaintext, buffer);
return new QuicData(reinterpret_cast<char*>(buffer), len, true);
}
- virtual size_t GetKeySize() const OVERRIDE { return 0; }
- virtual size_t GetNoncePrefixSize() const OVERRIDE { return 0; }
+ virtual size_t GetKeySize() const override { return 0; }
+ virtual size_t GetNoncePrefixSize() const override { return 0; }
- virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
+ virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
return ciphertext_size - kTagSize;
}
- virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
+ virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
return plaintext_size + kTagSize;
}
- virtual StringPiece GetKey() const OVERRIDE {
+ virtual StringPiece GetKey() const override {
return StringPiece();
}
- virtual StringPiece GetNoncePrefix() const OVERRIDE {
+ virtual StringPiece GetNoncePrefix() const override {
return StringPiece();
}
@@ -153,8 +153,8 @@
virtual ~TaggingDecrypter() {}
// QuicDecrypter interface
- virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
- virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+ virtual bool SetKey(StringPiece key) override { return true; }
+ virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
return true;
}
@@ -162,7 +162,7 @@
StringPiece associated_data,
StringPiece ciphertext,
unsigned char* output,
- size_t* output_length) OVERRIDE {
+ size_t* output_length) override {
if (ciphertext.size() < kTagSize) {
return false;
}
@@ -176,7 +176,7 @@
virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
StringPiece associated_data,
- StringPiece ciphertext) OVERRIDE {
+ StringPiece ciphertext) override {
if (ciphertext.size() < kTagSize) {
return nullptr;
}
@@ -190,8 +190,8 @@
true /* owns buffer */);
}
- virtual StringPiece GetKey() const OVERRIDE { return StringPiece(); }
- virtual StringPiece GetNoncePrefix() const OVERRIDE { return StringPiece(); }
+ virtual StringPiece GetKey() const override { return StringPiece(); }
+ virtual StringPiece GetNoncePrefix() const override { return StringPiece(); }
protected:
virtual uint8 GetTag(StringPiece ciphertext) {
@@ -222,7 +222,7 @@
virtual ~StrictTaggingDecrypter() {}
// TaggingQuicDecrypter
- virtual uint8 GetTag(StringPiece ciphertext) OVERRIDE {
+ virtual uint8 GetTag(StringPiece ciphertext) override {
return tag_;
}
@@ -238,8 +238,8 @@
: QuicAlarm(delegate) {
}
- virtual void SetImpl() OVERRIDE {}
- virtual void CancelImpl() OVERRIDE {}
+ virtual void SetImpl() override {}
+ virtual void CancelImpl() override {}
using QuicAlarm::Fire;
};
@@ -250,15 +250,15 @@
}
// QuicConnectionHelperInterface
- virtual const QuicClock* GetClock() const OVERRIDE {
+ virtual const QuicClock* GetClock() const override {
return clock_;
}
- virtual QuicRandom* GetRandomGenerator() OVERRIDE {
+ virtual QuicRandom* GetRandomGenerator() override {
return random_generator_;
}
- virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE {
+ virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
return new TestAlarm(delegate);
}
@@ -288,7 +288,7 @@
virtual WriteResult WritePacket(
const char* buffer, size_t buf_len,
const IPAddressNumber& self_address,
- const IPEndPoint& peer_address) OVERRIDE {
+ const IPEndPoint& peer_address) override {
QuicEncryptedPacket packet(buffer, buf_len);
++packets_write_attempts_;
@@ -313,13 +313,13 @@
return WriteResult(WRITE_STATUS_OK, last_packet_size_);
}
- virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
+ virtual bool IsWriteBlockedDataBuffered() const override {
return is_write_blocked_data_buffered_;
}
- virtual bool IsWriteBlocked() const OVERRIDE { return write_blocked_; }
+ virtual bool IsWriteBlocked() const override { return write_blocked_; }
- virtual void SetWritable() OVERRIDE { write_blocked_ = false; }
+ virtual void SetWritable() override { write_blocked_ = false; }
void BlockOnNextWrite() { block_on_next_write_ = true; }
@@ -591,7 +591,7 @@
: public QuicConnectionDebugVisitor {
public:
virtual void OnRevivedPacket(const QuicPacketHeader& header,
- StringPiece data) OVERRIDE {
+ StringPiece data) override {
revived_header_ = header;
}
@@ -2416,19 +2416,22 @@
}
TEST_P(QuicConnectionTest, BufferNonDecryptablePackets) {
+ // SetFromConfig is always called after construction from InitializeSession.
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ QuicConfig config;
+ connection_.SetFromConfig(config);
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
use_tagging_decrypter();
const uint8 tag = 0x07;
framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
- // Process an encrypted packet which can not yet be decrypted
- // which should result in the packet being buffered.
+ // Process an encrypted packet which can not yet be decrypted which should
+ // result in the packet being buffered.
ProcessDataPacketAtLevel(1, 0, kEntropyFlag, ENCRYPTION_INITIAL);
- // Transition to the new encryption state and process another
- // encrypted packet which should result in the original packet being
- // processed.
+ // Transition to the new encryption state and process another encrypted packet
+ // which should result in the original packet being processed.
connection_.SetDecrypter(new StrictTaggingDecrypter(tag),
ENCRYPTION_INITIAL);
connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
@@ -2436,12 +2439,44 @@
EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(2);
ProcessDataPacketAtLevel(2, 0, kEntropyFlag, ENCRYPTION_INITIAL);
- // Finally, process a third packet and note that we do not
- // reprocess the buffered packet.
+ // Finally, process a third packet and note that we do not reprocess the
+ // buffered packet.
EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
ProcessDataPacketAtLevel(3, 0, kEntropyFlag, ENCRYPTION_INITIAL);
}
+TEST_P(QuicConnectionTest, Buffer100NonDecryptablePackets) {
+ // SetFromConfig is always called after construction from InitializeSession.
+ EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+ QuicConfig config;
+ config.set_max_undecryptable_packets(100);
+ connection_.SetFromConfig(config);
+ EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+ use_tagging_decrypter();
+
+ const uint8 tag = 0x07;
+ framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
+
+ // Process an encrypted packet which can not yet be decrypted which should
+ // result in the packet being buffered.
+ for (QuicPacketSequenceNumber i = 1; i <= 100; ++i) {
+ ProcessDataPacketAtLevel(i, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+ }
+
+ // Transition to the new encryption state and process another encrypted packet
+ // which should result in the original packets being processed.
+ connection_.SetDecrypter(new StrictTaggingDecrypter(tag), ENCRYPTION_INITIAL);
+ connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
+ connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
+ EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(101);
+ ProcessDataPacketAtLevel(101, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+
+ // Finally, process a third packet and note that we do not reprocess the
+ // buffered packet.
+ EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
+ ProcessDataPacketAtLevel(102, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+}
+
TEST_P(QuicConnectionTest, TestRetransmitOrder) {
QuicByteCount first_packet_size;
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).WillOnce(
@@ -2682,7 +2717,6 @@
// SetFromConfig sets the initial timeouts before negotiation.
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
QuicConfig config;
- config.SetDefaults();
connection_.SetFromConfig(config);
// Subtract a second from the idle timeout on the client side.
QuicTime default_timeout = clock_.ApproximateNow().Add(
@@ -2835,7 +2869,6 @@
EXPECT_TRUE(connection_.connected());
EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
QuicConfig config;
- config.SetDefaults();
connection_.SetFromConfig(config);
const QuicTime::Delta initial_idle_timeout =
@@ -3924,12 +3957,12 @@
void(const QuicFrame&));
MOCK_METHOD6(OnPacketSent,
- void(QuicPacketSequenceNumber,
+ void(const SerializedPacket&,
QuicPacketSequenceNumber,
EncryptionLevel,
TransmissionType,
const QuicEncryptedPacket&,
- WriteResult));
+ QuicTime));
MOCK_METHOD3(OnPacketReceived,
void(const IPEndPoint&,
diff --git a/net/quic/quic_crypto_client_stream.h b/net/quic/quic_crypto_client_stream.h
index 96d2556..801c3da 100644
--- a/net/quic/quic_crypto_client_stream.h
+++ b/net/quic/quic_crypto_client_stream.h
@@ -33,7 +33,7 @@
// CryptoFramerVisitorInterface implementation
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
// Performs a crypto handshake with the server. Returns true if the crypto
// handshake is started successfully.
@@ -62,7 +62,7 @@
virtual ~ChannelIDSourceCallbackImpl();
// ChannelIDSourceCallback interface.
- virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) OVERRIDE;
+ virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) override;
// Cancel causes any future callbacks to be ignored. It must be called on
// the same thread as the callback will be made on.
@@ -83,7 +83,7 @@
// ProofVerifierCallback interface.
virtual void Run(bool ok,
const string& error_details,
- scoped_ptr<ProofVerifyDetails>* details) OVERRIDE;
+ scoped_ptr<ProofVerifyDetails>* details) override;
// Cancel causes any future callbacks to be ignored. It must be called on
// the same thread as the callback will be made on.
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index 5a8b08c..1df2313 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -34,8 +34,6 @@
stream_(new QuicCryptoClientStream(server_id_, session_.get(), nullptr,
&crypto_config_)) {
session_->SetCryptoStream(stream_.get());
- session_->config()->SetDefaults();
- crypto_config_.SetDefaults();
}
void CompleteCryptoHandshake() {
@@ -127,7 +125,6 @@
&crypto_config_));
session_->SetCryptoStream(stream_.get());
- session_->config()->SetDefaults();
// Advance time 5 years to ensure that we pass the expiry time of the cached
// server config.
diff --git a/net/quic/quic_crypto_server_stream.cc b/net/quic/quic_crypto_server_stream.cc
index eebab90..e912c32 100644
--- a/net/quic/quic_crypto_server_stream.cc
+++ b/net/quic/quic_crypto_server_stream.cc
@@ -11,6 +11,7 @@
#include "net/quic/crypto/quic_crypto_server_config.h"
#include "net/quic/crypto/source_address_token.h"
#include "net/quic/quic_config.h"
+#include "net/quic/quic_flags.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/quic_session.h"
@@ -152,11 +153,12 @@
// Now that the handshake is complete, send an updated server config and
// source-address token to the client.
- SendServerConfigUpdate(nullptr);
+ SendServerConfigUpdate(previous_cached_network_params_.get(), true);
}
void QuicCryptoServerStream::SendServerConfigUpdate(
- const CachedNetworkParameters* cached_network_params) {
+ const CachedNetworkParameters* cached_network_params,
+ bool on_handshake_complete) {
if (session()->connection()->version() <= QUIC_VERSION_21 ||
!handshake_confirmed_) {
return;
@@ -174,7 +176,8 @@
return;
}
- DVLOG(1) << "Server: Sending server config update: "
+ DVLOG(1) << "Server: Sending server config update"
+ << (on_handshake_complete ? " immediately after handshake: " : ": ")
<< server_config_update_message.DebugString();
const QuicData& data = server_config_update_message.GetSerialized();
WriteOrBufferData(string(data.data(), data.length()), false, nullptr);
@@ -221,6 +224,13 @@
const ValidateClientHelloResultCallback::Result& result,
CryptoHandshakeMessage* reply,
string* error_details) {
+ // Store the bandwidth estimate from the client.
+ if (FLAGS_quic_store_cached_network_params_from_chlo &&
+ result.cached_network_params.bandwidth_estimate_bytes_per_second() > 0) {
+ previous_cached_network_params_.reset(
+ new CachedNetworkParameters(result.cached_network_params));
+ }
+
return crypto_config_.ProcessClientHello(
result,
session()->connection()->connection_id(),
diff --git a/net/quic/quic_crypto_server_stream.h b/net/quic/quic_crypto_server_stream.h
index 46ac4f3..5d55564 100644
--- a/net/quic/quic_crypto_server_stream.h
+++ b/net/quic/quic_crypto_server_stream.h
@@ -38,7 +38,7 @@
int num_original_bytes,
int num_retransmitted_packets,
int num_retransmitted_bytes,
- QuicTime::Delta delta_largest_observed) OVERRIDE;
+ QuicTime::Delta delta_largest_observed) override;
private:
virtual ~ServerHelloNotifier() {}
@@ -60,7 +60,7 @@
// CryptoFramerVisitorInterface implementation
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
// GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
// SHA-256 hash of the client's ChannelID key and returns true, if the client
@@ -74,8 +74,11 @@
}
// Sends the latest server config and source-address token to the client.
+ // |on_handshake_complete| is true when this is called immediately after
+ // handshake completes, and should be false for subsequent updates.
virtual void SendServerConfigUpdate(
- const CachedNetworkParameters* cached_network_params);
+ const CachedNetworkParameters* cached_network_params,
+ bool on_handshake_complete);
// Called by the ServerHello AckNotifier once the SHLO has been ACKed by the
// client.
@@ -103,7 +106,7 @@
// From ValidateClientHelloResultCallback
virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
- const Result& result) OVERRIDE;
+ const Result& result) override;
private:
QuicCryptoServerStream* parent_;
@@ -133,6 +136,11 @@
// Number of server config update (SCUP) messages sent by this stream.
int num_server_config_update_messages_sent_;
+ // If the client provides CachedNetworkParameters in the STK in the CHLO, then
+ // store here, and send back in future STKs if we have no better bandwidth
+ // estimate to send.
+ scoped_ptr<CachedNetworkParameters> previous_cached_network_params_;
+
DISALLOW_COPY_AND_ASSIGN(QuicCryptoServerStream);
};
diff --git a/net/quic/quic_crypto_server_stream_test.cc b/net/quic/quic_crypto_server_stream_test.cc
index 6ce059b..38b4a57 100644
--- a/net/quic/quic_crypto_server_stream_test.cc
+++ b/net/quic/quic_crypto_server_stream_test.cc
@@ -61,8 +61,6 @@
QuicRandom::GetInstance()),
stream_(crypto_config_, &session_),
strike_register_client_(nullptr) {
- config_.SetDefaults();
- session_.config()->SetDefaults();
session_.SetCryptoStream(&stream_);
// We advance the clock initially because the default time is zero and the
// strike register worries that we've just overflowed a uint32 time.
@@ -141,11 +139,9 @@
server_conn->AdvanceTime(QuicTime::Delta::FromSeconds(100000));
QuicConfig client_config;
- client_config.SetDefaults();
scoped_ptr<TestClientSession> client_session(
new TestClientSession(client_conn, client_config));
QuicCryptoClientConfig client_crypto_config;
- client_crypto_config.SetDefaults();
QuicServerId server_id(kServerHostname, kServerPort, false,
PRIVACY_MODE_DISABLED);
@@ -277,7 +273,7 @@
TEST_P(QuicCryptoServerStreamTest, OnlySendSCUPAfterHandshakeComplete) {
// An attempt to send a SCUP before completing handshake should fail.
- stream_.SendServerConfigUpdate(nullptr);
+ stream_.SendServerConfigUpdate(nullptr, false);
EXPECT_EQ(0, stream_.num_server_config_update_messages_sent());
}
diff --git a/net/quic/quic_crypto_stream.h b/net/quic/quic_crypto_stream.h
index dc8b227..6698e3e 100644
--- a/net/quic/quic_crypto_stream.h
+++ b/net/quic/quic_crypto_stream.h
@@ -34,13 +34,13 @@
explicit QuicCryptoStream(QuicSession* session);
// CryptoFramerVisitorInterface implementation
- virtual void OnError(CryptoFramer* framer) OVERRIDE;
+ virtual void OnError(CryptoFramer* framer) override;
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
// ReliableQuicStream implementation
- virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
- virtual QuicPriority EffectivePriority() const OVERRIDE;
+ virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
+ virtual QuicPriority EffectivePriority() const override;
// Sends |message| to the peer.
// TODO(wtc): return a success/failure status.
diff --git a/net/quic/quic_crypto_stream_test.cc b/net/quic/quic_crypto_stream_test.cc
index 4ea8f49..e79a1f3 100644
--- a/net/quic/quic_crypto_stream_test.cc
+++ b/net/quic/quic_crypto_stream_test.cc
@@ -30,7 +30,7 @@
}
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE {
+ const CryptoHandshakeMessage& message) override {
messages_.push_back(message);
}
diff --git a/net/quic/quic_data_stream.h b/net/quic/quic_data_stream.h
index 1af9004..7cb9816 100644
--- a/net/quic/quic_data_stream.h
+++ b/net/quic/quic_data_stream.h
@@ -57,13 +57,13 @@
virtual ~QuicDataStream();
// ReliableQuicStream implementation
- virtual void OnClose() OVERRIDE;
- virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
+ virtual void OnClose() override;
+ virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
// By default, this is the same as priority(), however it allows streams
// to temporarily alter effective priority. For example if a SPDY stream has
// compressed but not written headers it can write the headers with a higher
// priority.
- virtual QuicPriority EffectivePriority() const OVERRIDE;
+ virtual QuicPriority EffectivePriority() const override;
// Overridden by subclasses to process data. The headers will be delivered
// via OnStreamHeaders, so only data will be delivered through this method.
diff --git a/net/quic/quic_data_stream_test.cc b/net/quic/quic_data_stream_test.cc
index 279dcd3..2f6d84e 100644
--- a/net/quic/quic_data_stream_test.cc
+++ b/net/quic/quic_data_stream_test.cc
@@ -40,7 +40,7 @@
: QuicDataStream(id, session),
should_process_data_(should_process_data) {}
- virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
+ virtual uint32 ProcessData(const char* data, uint32 data_len) override {
EXPECT_NE(0u, data_len);
DVLOG(1) << "ProcessData data_len: " << data_len;
data_ += string(data, data_len);
diff --git a/net/quic/quic_default_packet_writer.h b/net/quic/quic_default_packet_writer.h
index 15eb0dd..329f7cc 100644
--- a/net/quic/quic_default_packet_writer.h
+++ b/net/quic/quic_default_packet_writer.h
@@ -29,10 +29,10 @@
virtual WriteResult WritePacket(const char* buffer,
size_t buf_len,
const IPAddressNumber& self_address,
- const IPEndPoint& peer_address) OVERRIDE;
- virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
- virtual bool IsWriteBlocked() const OVERRIDE;
- virtual void SetWritable() OVERRIDE;
+ const IPEndPoint& peer_address) override;
+ virtual bool IsWriteBlockedDataBuffered() const override;
+ virtual bool IsWriteBlocked() const override;
+ virtual void SetWritable() override;
void OnWriteComplete(int rv);
void SetConnection(QuicConnection* connection) {
diff --git a/net/quic/quic_dispatcher.cc b/net/quic/quic_dispatcher.cc
index a72faa6..121e32f 100644
--- a/net/quic/quic_dispatcher.cc
+++ b/net/quic/quic_dispatcher.cc
@@ -28,7 +28,7 @@
: dispatcher_(dispatcher) {
}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
dispatcher_->DeleteSessions();
return QuicTime::Zero();
}
@@ -44,23 +44,23 @@
connection_id_(0) {}
// QuicFramerVisitorInterface implementation
- virtual void OnPacket() OVERRIDE {}
+ virtual void OnPacket() override {}
virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) OVERRIDE {
+ const QuicPacketPublicHeader& header) override {
connection_id_ = header.connection_id;
return dispatcher_->OnUnauthenticatedPublicHeader(header);
}
virtual bool OnUnauthenticatedHeader(
- const QuicPacketHeader& header) OVERRIDE {
+ const QuicPacketHeader& header) override {
dispatcher_->OnUnauthenticatedHeader(header);
return false;
}
- virtual void OnError(QuicFramer* framer) OVERRIDE {
+ virtual void OnError(QuicFramer* framer) override {
DVLOG(1) << QuicUtils::ErrorToString(framer->error());
}
virtual bool OnProtocolVersionMismatch(
- QuicVersion /*received_version*/) OVERRIDE {
+ QuicVersion /*received_version*/) override {
if (dispatcher_->time_wait_list_manager()->IsConnectionIdInTimeWait(
connection_id_)) {
// Keep processing after protocol mismatch - this will be dealt with by
@@ -77,74 +77,74 @@
// false from OnUnauthenticatedHeader(). As a result, we never process the
// payload of the packet.
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& /*packet*/) OVERRIDE {
+ const QuicPublicResetPacket& /*packet*/) override {
DCHECK(false);
}
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& /*packet*/) OVERRIDE {
+ const QuicVersionNegotiationPacket& /*packet*/) override {
DCHECK(false);
}
- virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {
+ virtual void OnDecryptedPacket(EncryptionLevel level) override {
DCHECK(false);
}
- virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) OVERRIDE {
+ virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
DCHECK(false);
return false;
}
- virtual void OnRevivedPacket() OVERRIDE {
+ virtual void OnRevivedPacket() override {
DCHECK(false);
}
- virtual void OnFecProtectedPayload(StringPiece /*payload*/) OVERRIDE {
+ virtual void OnFecProtectedPayload(StringPiece /*payload*/) override {
DCHECK(false);
}
- virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) OVERRIDE {
+ virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override {
DCHECK(false);
return false;
}
- virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) OVERRIDE {
+ virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) override {
DCHECK(false);
return false;
}
virtual bool OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& /*frame*/) OVERRIDE {
+ const QuicCongestionFeedbackFrame& /*frame*/) override {
DCHECK(false);
return false;
}
virtual bool OnStopWaitingFrame(
- const QuicStopWaitingFrame& /*frame*/) OVERRIDE {
+ const QuicStopWaitingFrame& /*frame*/) override {
DCHECK(false);
return false;
}
- virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) OVERRIDE {
+ virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) override {
DCHECK(false);
return false;
}
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) OVERRIDE {
+ virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
DCHECK(false);
return false;
}
virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame & /*frame*/) OVERRIDE {
+ const QuicConnectionCloseFrame & /*frame*/) override {
DCHECK(false);
return false;
}
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) OVERRIDE {
+ virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override {
DCHECK(false);
return false;
}
virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/)
- OVERRIDE {
+ override {
DCHECK(false);
return false;
}
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+ virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
DCHECK(false);
return false;
}
- virtual void OnFecData(const QuicFecData& /*fec*/) OVERRIDE {
+ virtual void OnFecData(const QuicFecData& /*fec*/) override {
DCHECK(false);
}
- virtual void OnPacketComplete() OVERRIDE {
+ virtual void OnPacketComplete() override {
DCHECK(false);
}
diff --git a/net/quic/quic_dispatcher.h b/net/quic/quic_dispatcher.h
index d07c46c..b4be0ee 100644
--- a/net/quic/quic_dispatcher.h
+++ b/net/quic/quic_dispatcher.h
@@ -64,7 +64,7 @@
virtual QuicPacketWriter* Create(
QuicServerPacketWriter* writer,
- QuicConnection* connection) OVERRIDE;
+ QuicConnection* connection) override;
};
// Ideally we'd have a linked_hash_set: the boolean is unused.
@@ -89,7 +89,7 @@
// an existing session, or passing it to the TimeWaitListManager.
virtual void ProcessPacket(const IPEndPoint& server_address,
const IPEndPoint& client_address,
- const QuicEncryptedPacket& packet) OVERRIDE;
+ const QuicEncryptedPacket& packet) override;
// Returns true if there's anything in the blocked writer list.
virtual bool HasPendingWrites() const;
@@ -99,16 +99,16 @@
// QuicBlockedWriterInterface implementation:
// Called when the socket becomes writable to allow queued writes to happen.
- virtual void OnCanWrite() OVERRIDE;
+ virtual void OnCanWrite() override;
// QuicServerSessionVisitor interface implementation:
// Ensure that the closed connection is cleaned up asynchronously.
virtual void OnConnectionClosed(QuicConnectionId connection_id,
- QuicErrorCode error) OVERRIDE;
+ QuicErrorCode error) override;
// Queues the blocked writer for later resumption.
virtual void OnWriteBlocked(
- QuicBlockedWriterInterface* blocked_writer) OVERRIDE;
+ QuicBlockedWriterInterface* blocked_writer) override;
typedef base::hash_map<QuicConnectionId, QuicSession*> SessionMap;
@@ -185,7 +185,7 @@
PacketWriterFactoryAdapter(QuicDispatcher* dispatcher);
virtual ~PacketWriterFactoryAdapter ();
- virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+ virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
private:
QuicDispatcher* dispatcher_;
diff --git a/net/quic/quic_end_to_end_unittest.cc b/net/quic/quic_end_to_end_unittest.cc
index a37bd19..b589bc6 100644
--- a/net/quic/quic_end_to_end_unittest.cc
+++ b/net/quic/quic_end_to_end_unittest.cc
@@ -7,6 +7,7 @@
#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
+#include "net/base/elements_upload_data_stream.h"
#include "net/base/test_completion_callback.h"
#include "net/base/upload_bytes_element_reader.h"
#include "net/base/upload_data_stream.h"
@@ -53,16 +54,16 @@
// HttpTransactionFactory methods
virtual int CreateTransaction(RequestPriority priority,
- scoped_ptr<HttpTransaction>* trans) OVERRIDE {
+ scoped_ptr<HttpTransaction>* trans) override {
trans->reset(new HttpNetworkTransaction(priority, session_.get()));
return OK;
}
- virtual HttpCache* GetCache() OVERRIDE {
+ virtual HttpCache* GetCache() override {
return nullptr;
}
- virtual HttpNetworkSession* GetSession() OVERRIDE { return session_.get(); };
+ virtual HttpNetworkSession* GetSession() override { return session_.get(); };
private:
scoped_refptr<HttpNetworkSession> session_;
@@ -132,7 +133,6 @@
net::IPAddressNumber ip;
CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
server_address_ = IPEndPoint(ip, 0);
- server_config_.SetDefaults();
server_config_.SetInitialFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
server_config_.SetInitialStreamFlowControlWindowToSend(
@@ -189,7 +189,8 @@
element_readers.push_back(
new UploadBytesElementReader(request_body_.data(),
request_body_.length()));
- upload_data_stream_.reset(new UploadDataStream(element_readers.Pass(), 0));
+ upload_data_stream_.reset(
+ new ElementsUploadDataStream(element_readers.Pass(), 0));
request_.method = "POST";
request_.url = GURL("http://www.google.com/");
request_.upload_data_stream = upload_data_stream_.get();
diff --git a/net/quic/quic_flags.cc b/net/quic/quic_flags.cc
index 864e12b..9a49a34 100644
--- a/net/quic/quic_flags.cc
+++ b/net/quic/quic_flags.cc
@@ -46,3 +46,7 @@
// If true, then QUIC connections will set both idle and overall timeouts in a
// single method.
bool FLAGS_quic_unified_timeouts = false;
+
+// If true, store any CachedNetworkParams that are provided in the STK from the
+// CHLO.
+bool FLAGS_quic_store_cached_network_params_from_chlo = false;
diff --git a/net/quic/quic_flags.h b/net/quic/quic_flags.h
index f1fea1e..7693260 100644
--- a/net/quic/quic_flags.h
+++ b/net/quic/quic_flags.h
@@ -18,5 +18,6 @@
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_store_cached_network_params_from_chlo;
#endif // NET_QUIC_QUIC_FLAGS_H_
diff --git a/net/quic/quic_flow_controller.cc b/net/quic/quic_flow_controller.cc
index b145280..722b243 100644
--- a/net/quic/quic_flow_controller.cc
+++ b/net/quic/quic_flow_controller.cc
@@ -163,10 +163,12 @@
DVLOG(1) << ENDPOINT << "UpdateSendWindowOffset for stream " << id_
<< " with new offset " << new_send_window_offset
- << " , current offset: " << send_window_offset_;
+ << " current offset: " << send_window_offset_
+ << " bytes_sent: " << bytes_sent_;
+ const bool blocked = IsBlocked();
send_window_offset_ = new_send_window_offset;
- return true;
+ return blocked;
}
void QuicFlowController::Disable() {
diff --git a/net/quic/quic_flow_controller.h b/net/quic/quic_flow_controller.h
index e5f5494..0df2b0e 100644
--- a/net/quic/quic_flow_controller.h
+++ b/net/quic/quic_flow_controller.h
@@ -47,8 +47,7 @@
void AddBytesSent(uint64 bytes_sent);
// Set a new send window offset.
- // Returns true if this changes send_window_offset_, and false in the case
- // where |new_send_window| is <= send_window_offset_.
+ // Returns true if this increases send_window_offset_ and is now blocked.
bool UpdateSendWindowOffset(uint64 new_send_window_offset);
// Returns the current available send window.
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 535d31a..9ba0fd6 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -104,43 +104,43 @@
class TestEncrypter : public QuicEncrypter {
public:
virtual ~TestEncrypter() {}
- virtual bool SetKey(StringPiece key) OVERRIDE {
+ virtual bool SetKey(StringPiece key) override {
return true;
}
- virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+ virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
return true;
}
virtual bool Encrypt(StringPiece nonce,
StringPiece associated_data,
StringPiece plaintext,
- unsigned char* output) OVERRIDE {
+ unsigned char* output) override {
CHECK(false) << "Not implemented";
return false;
}
virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
StringPiece associated_data,
- StringPiece plaintext) OVERRIDE {
+ StringPiece plaintext) override {
sequence_number_ = sequence_number;
associated_data_ = associated_data.as_string();
plaintext_ = plaintext.as_string();
return new QuicData(plaintext.data(), plaintext.length());
}
- virtual size_t GetKeySize() const OVERRIDE {
+ virtual size_t GetKeySize() const override {
return 0;
}
- virtual size_t GetNoncePrefixSize() const OVERRIDE {
+ virtual size_t GetNoncePrefixSize() const override {
return 0;
}
- virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
+ virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
return ciphertext_size;
}
- virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
+ virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
return plaintext_size;
}
- virtual StringPiece GetKey() const OVERRIDE {
+ virtual StringPiece GetKey() const override {
return StringPiece();
}
- virtual StringPiece GetNoncePrefix() const OVERRIDE {
+ virtual StringPiece GetNoncePrefix() const override {
return StringPiece();
}
QuicPacketSequenceNumber sequence_number_;
@@ -151,32 +151,32 @@
class TestDecrypter : public QuicDecrypter {
public:
virtual ~TestDecrypter() {}
- virtual bool SetKey(StringPiece key) OVERRIDE {
+ virtual bool SetKey(StringPiece key) override {
return true;
}
- virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+ virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
return true;
}
virtual bool Decrypt(StringPiece nonce,
StringPiece associated_data,
StringPiece ciphertext,
unsigned char* output,
- size_t* output_length) OVERRIDE {
+ size_t* output_length) override {
CHECK(false) << "Not implemented";
return false;
}
virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
StringPiece associated_data,
- StringPiece ciphertext) OVERRIDE {
+ StringPiece ciphertext) override {
sequence_number_ = sequence_number;
associated_data_ = associated_data.as_string();
ciphertext_ = ciphertext.as_string();
return new QuicData(ciphertext.data(), ciphertext.length());
}
- virtual StringPiece GetKey() const OVERRIDE {
+ virtual StringPiece GetKey() const override {
return StringPiece();
}
- virtual StringPiece GetNoncePrefix() const OVERRIDE {
+ virtual StringPiece GetNoncePrefix() const override {
return StringPiece();
}
QuicPacketSequenceNumber sequence_number_;
@@ -207,121 +207,121 @@
STLDeleteElements(&fec_data_);
}
- virtual void OnError(QuicFramer* f) OVERRIDE {
+ virtual void OnError(QuicFramer* f) override {
DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
<< " (" << f->error() << ")";
++error_count_;
}
- virtual void OnPacket() OVERRIDE {}
+ virtual void OnPacket() override {}
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& packet) OVERRIDE {
+ const QuicPublicResetPacket& packet) override {
public_reset_packet_.reset(new QuicPublicResetPacket(packet));
}
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) OVERRIDE {
+ const QuicVersionNegotiationPacket& packet) override {
version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
}
- virtual void OnRevivedPacket() OVERRIDE {
+ virtual void OnRevivedPacket() override {
++revived_packets_;
}
- virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+ virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
DVLOG(1) << "QuicFramer Version Mismatch, version: " << version;
++version_mismatch_;
return true;
}
virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) OVERRIDE {
+ const QuicPacketPublicHeader& header) override {
public_header_.reset(new QuicPacketPublicHeader(header));
return accept_public_header_;
}
virtual bool OnUnauthenticatedHeader(
- const QuicPacketHeader& header) OVERRIDE {
+ const QuicPacketHeader& header) override {
return true;
}
- virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
+ virtual void OnDecryptedPacket(EncryptionLevel level) override {}
- virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
+ virtual bool OnPacketHeader(const QuicPacketHeader& header) override {
++packet_count_;
header_.reset(new QuicPacketHeader(header));
return accept_packet_;
}
- virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
+ virtual bool OnStreamFrame(const QuicStreamFrame& frame) override {
++frame_count_;
stream_frames_.push_back(new QuicStreamFrame(frame));
return true;
}
- virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {
+ virtual void OnFecProtectedPayload(StringPiece payload) override {
fec_protected_payload_ = payload.as_string();
}
- virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
+ virtual bool OnAckFrame(const QuicAckFrame& frame) override {
++frame_count_;
ack_frames_.push_back(new QuicAckFrame(frame));
return true;
}
virtual bool OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) OVERRIDE {
+ const QuicCongestionFeedbackFrame& frame) override {
++frame_count_;
congestion_feedback_frames_.push_back(
new QuicCongestionFeedbackFrame(frame));
return true;
}
- virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+ virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
++frame_count_;
stop_waiting_frames_.push_back(new QuicStopWaitingFrame(frame));
return true;
}
- virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
+ virtual bool OnPingFrame(const QuicPingFrame& frame) override {
++frame_count_;
ping_frames_.push_back(new QuicPingFrame(frame));
return true;
}
- virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
+ virtual void OnFecData(const QuicFecData& fec) override {
++fec_count_;
fec_data_.push_back(new QuicFecData(fec));
}
- virtual void OnPacketComplete() OVERRIDE {
+ virtual void OnPacketComplete() override {
++complete_packets_;
}
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
+ virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
rst_stream_frame_ = frame;
return true;
}
virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) OVERRIDE {
+ const QuicConnectionCloseFrame& frame) override {
connection_close_frame_ = frame;
return true;
}
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
+ virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
goaway_frame_ = frame;
return true;
}
virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame)
- OVERRIDE {
+ override {
window_update_frame_ = frame;
return true;
}
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+ virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
blocked_frame_ = frame;
return true;
}
diff --git a/net/quic/quic_headers_stream.cc b/net/quic/quic_headers_stream.cc
index 35dac3f..56b700e 100644
--- a/net/quic/quic_headers_stream.cc
+++ b/net/quic/quic_headers_stream.cc
@@ -30,7 +30,7 @@
SpdyStreamId associated_stream_id,
SpdyPriority priority,
bool fin,
- bool unidirectional) OVERRIDE {
+ bool unidirectional) override {
if (!stream_->IsConnected()) {
return;
}
@@ -48,7 +48,7 @@
stream_->OnSynStream(stream_id, priority, fin);
}
- virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
+ virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
if (!stream_->IsConnected()) {
return;
}
@@ -58,7 +58,7 @@
virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
const char* header_data,
- size_t len) OVERRIDE {
+ size_t len) override {
if (!stream_->IsConnected()) {
return false;
}
@@ -69,7 +69,7 @@
virtual void OnStreamFrameData(SpdyStreamId stream_id,
const char* data,
size_t len,
- bool fin) OVERRIDE {
+ bool fin) override {
if (fin && len == 0) {
// The framer invokes OnStreamFrameData with zero-length data and
// fin = true after processing a SYN_STREAM or SYN_REPLY frame
@@ -79,65 +79,65 @@
CloseConnection("SPDY DATA frame received.");
}
- virtual void OnError(SpdyFramer* framer) OVERRIDE {
+ virtual void OnError(SpdyFramer* framer) override {
CloseConnection("SPDY framing error.");
}
virtual void OnDataFrameHeader(SpdyStreamId stream_id,
size_t length,
- bool fin) OVERRIDE {
+ bool fin) override {
CloseConnection("SPDY DATA frame received.");
}
virtual void OnRstStream(SpdyStreamId stream_id,
- SpdyRstStreamStatus status) OVERRIDE {
+ SpdyRstStreamStatus status) override {
CloseConnection("SPDY RST_STREAM frame received.");
}
virtual void OnSetting(SpdySettingsIds id,
uint8 flags,
- uint32 value) OVERRIDE {
+ uint32 value) override {
CloseConnection("SPDY SETTINGS frame received.");
}
- virtual void OnSettingsAck() OVERRIDE {
+ virtual void OnSettingsAck() override {
CloseConnection("SPDY SETTINGS frame received.");
}
- virtual void OnSettingsEnd() OVERRIDE {
+ virtual void OnSettingsEnd() override {
CloseConnection("SPDY SETTINGS frame received.");
}
- virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
+ virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
CloseConnection("SPDY PING frame received.");
}
virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
- SpdyGoAwayStatus status) OVERRIDE {
+ SpdyGoAwayStatus status) override {
CloseConnection("SPDY GOAWAY frame received.");
}
- virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
+ virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
CloseConnection("SPDY HEADERS frame received.");
}
virtual void OnWindowUpdate(SpdyStreamId stream_id,
- uint32 delta_window_size) OVERRIDE {
+ uint32 delta_window_size) override {
CloseConnection("SPDY WINDOW_UPDATE frame received.");
}
virtual void OnPushPromise(SpdyStreamId stream_id,
SpdyStreamId promised_stream_id,
- bool end) OVERRIDE {
+ bool end) override {
LOG(DFATAL) << "PUSH_PROMISE frame received from a SPDY/3 framer";
CloseConnection("SPDY PUSH_PROMISE frame received.");
}
- virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
+ virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
CloseConnection("SPDY CONTINUATION frame received.");
}
- virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+ virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
CloseConnection("SPDY unknown frame received.");
return false;
}
@@ -146,11 +146,11 @@
virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
SpdyFrameType type,
size_t payload_len,
- size_t frame_len) OVERRIDE {}
+ size_t frame_len) override {}
virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
SpdyFrameType type,
- size_t frame_len) OVERRIDE {
+ size_t frame_len) override {
if (stream_->IsConnected()) {
stream_->OnCompressedFrameSize(frame_len);
}
diff --git a/net/quic/quic_headers_stream.h b/net/quic/quic_headers_stream.h
index c3ccbda..fb96ec7 100644
--- a/net/quic/quic_headers_stream.h
+++ b/net/quic/quic_headers_stream.h
@@ -34,8 +34,8 @@
QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
// ReliableQuicStream implementation
- virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
- virtual QuicPriority EffectivePriority() const OVERRIDE;
+ virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
+ virtual QuicPriority EffectivePriority() const override;
private:
class SpdyFramerVisitor;
diff --git a/net/quic/quic_http_stream.h b/net/quic/quic_http_stream.h
index 5c60822..44e98e8 100644
--- a/net/quic/quic_http_stream.h
+++ b/net/quic/quic_http_stream.h
@@ -35,41 +35,41 @@
virtual int InitializeStream(const HttpRequestInfo* request_info,
RequestPriority priority,
const BoundNetLog& net_log,
- const CompletionCallback& callback) OVERRIDE;
+ const CompletionCallback& callback) override;
virtual int SendRequest(const HttpRequestHeaders& request_headers,
HttpResponseInfo* response,
- const CompletionCallback& callback) OVERRIDE;
- virtual UploadProgress GetUploadProgress() const OVERRIDE;
- virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+ const CompletionCallback& callback) override;
+ virtual UploadProgress GetUploadProgress() const override;
+ virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
virtual int ReadResponseBody(IOBuffer* buf,
int buf_len,
- const CompletionCallback& callback) OVERRIDE;
- virtual void Close(bool not_reusable) OVERRIDE;
- virtual HttpStream* RenewStreamForAuth() OVERRIDE;
- virtual bool IsResponseBodyComplete() const OVERRIDE;
- virtual bool CanFindEndOfResponse() const OVERRIDE;
- virtual bool IsConnectionReused() const OVERRIDE;
- virtual void SetConnectionReused() OVERRIDE;
- virtual bool IsConnectionReusable() const OVERRIDE;
- virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+ const CompletionCallback& callback) override;
+ virtual void Close(bool not_reusable) override;
+ virtual HttpStream* RenewStreamForAuth() override;
+ virtual bool IsResponseBodyComplete() const override;
+ virtual bool CanFindEndOfResponse() const override;
+ virtual bool IsConnectionReused() const override;
+ virtual void SetConnectionReused() override;
+ virtual bool IsConnectionReusable() const override;
+ virtual int64 GetTotalReceivedBytes() const override;
virtual bool GetLoadTimingInfo(
- LoadTimingInfo* load_timing_info) const OVERRIDE;
- virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+ LoadTimingInfo* load_timing_info) const override;
+ virtual void GetSSLInfo(SSLInfo* ssl_info) override;
virtual void GetSSLCertRequestInfo(
- SSLCertRequestInfo* cert_request_info) OVERRIDE;
- virtual bool IsSpdyHttpStream() const OVERRIDE;
- virtual void Drain(HttpNetworkSession* session) OVERRIDE;
- virtual void SetPriority(RequestPriority priority) OVERRIDE;
+ SSLCertRequestInfo* cert_request_info) override;
+ virtual bool IsSpdyHttpStream() const override;
+ virtual void Drain(HttpNetworkSession* session) override;
+ virtual void SetPriority(RequestPriority priority) override;
// QuicReliableClientStream::Delegate implementation
- virtual int OnDataReceived(const char* data, int length) OVERRIDE;
- virtual void OnClose(QuicErrorCode error) OVERRIDE;
- virtual void OnError(int error) OVERRIDE;
- virtual bool HasSendHeadersComplete() OVERRIDE;
+ virtual int OnDataReceived(const char* data, int length) override;
+ virtual void OnClose(QuicErrorCode error) override;
+ virtual void OnError(int error) override;
+ virtual bool HasSendHeadersComplete() override;
// QuicClientSession::Observer implementation
- virtual void OnCryptoHandshakeConfirmed() OVERRIDE;
- virtual void OnSessionClosed(int error) OVERRIDE;
+ virtual void OnCryptoHandshakeConfirmed() override;
+ virtual void OnSessionClosed(int error) override;
private:
friend class test::QuicHttpStreamPeer;
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 313e7f5..b6ecc77 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -6,10 +6,11 @@
#include <vector>
+#include "net/base/chunked_upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
#include "net/base/net_errors.h"
#include "net/base/test_completion_callback.h"
#include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
#include "net/http/http_response_headers.h"
#include "net/http/transport_security_state.h"
#include "net/quic/congestion_control/receive_algorithm_interface.h"
@@ -97,7 +98,7 @@
: QuicHttpStream(session) {
}
- virtual int OnDataReceived(const char* data, int length) OVERRIDE {
+ virtual int OnDataReceived(const char* data, int length) override {
Close(false);
return OK;
}
@@ -109,7 +110,7 @@
: socket_(socket) {}
virtual ~TestPacketWriterFactory() {}
- virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE {
+ virtual QuicPacketWriter* Create(QuicConnection* connection) const override {
return new QuicDefaultPacketWriter(socket_);
}
@@ -224,7 +225,6 @@
connection_->set_visitor(&visitor_);
connection_->SetSendAlgorithm(send_algorithm_);
connection_->SetReceiveAlgorithm(receive_algorithm_);
- crypto_config_.SetDefaults();
session_.reset(
new QuicClientSession(connection_,
scoped_ptr<DatagramClientSocket>(socket),
@@ -489,7 +489,7 @@
ScopedVector<UploadElementReader> element_readers;
element_readers.push_back(
new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
- UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+ ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
request_.method = "POST";
request_.url = GURL("http://www.google.com/");
request_.upload_data_stream = &upload_data_stream;
@@ -535,20 +535,21 @@
AddWrite(ConstructAckPacket(4, 3, 1));
Initialize();
- UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
- upload_data_stream.AppendChunk(kUploadData, chunk_size, false);
+ ChunkedUploadDataStream upload_data_stream(0);
+ upload_data_stream.AppendData(kUploadData, chunk_size, false);
request_.method = "POST";
request_.url = GURL("http://www.google.com/");
request_.upload_data_stream = &upload_data_stream;
- ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+ ASSERT_EQ(OK, request_.upload_data_stream->Init(
+ TestCompletionCallback().callback()));
ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
net_log_, callback_.callback()));
ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
callback_.callback()));
- upload_data_stream.AppendChunk(kUploadData, chunk_size, true);
+ upload_data_stream.AppendData(kUploadData, chunk_size, true);
// Ack both packets in the request.
ProcessPacket(ConstructAckPacket(1, 0, 0));
@@ -586,20 +587,21 @@
AddWrite(ConstructAckPacket(4, 3, 1));
Initialize();
- UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
- upload_data_stream.AppendChunk(kUploadData, chunk_size, false);
+ ChunkedUploadDataStream upload_data_stream(0);
+ upload_data_stream.AppendData(kUploadData, chunk_size, false);
request_.method = "POST";
request_.url = GURL("http://www.google.com/");
request_.upload_data_stream = &upload_data_stream;
- ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+ ASSERT_EQ(OK, request_.upload_data_stream->Init(
+ TestCompletionCallback().callback()));
ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
net_log_, callback_.callback()));
ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
callback_.callback()));
- upload_data_stream.AppendChunk(nullptr, 0, true);
+ upload_data_stream.AppendData(nullptr, 0, true);
ProcessPacket(ConstructAckPacket(1, 0, 0));
@@ -634,19 +636,20 @@
AddWrite(ConstructAckPacket(3, 3, 1));
Initialize();
- UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
+ ChunkedUploadDataStream upload_data_stream(0);
request_.method = "POST";
request_.url = GURL("http://www.google.com/");
request_.upload_data_stream = &upload_data_stream;
- ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+ ASSERT_EQ(OK, request_.upload_data_stream->Init(
+ TestCompletionCallback().callback()));
ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
net_log_, callback_.callback()));
ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
callback_.callback()));
- upload_data_stream.AppendChunk(nullptr, 0, true);
+ upload_data_stream.AppendData(nullptr, 0, true);
ProcessPacket(ConstructAckPacket(1, 0, 0));
diff --git a/net/quic/quic_packet_creator.h b/net/quic/quic_packet_creator.h
index 313632e..cb4cb05 100644
--- a/net/quic/quic_packet_creator.h
+++ b/net/quic/quic_packet_creator.h
@@ -38,7 +38,7 @@
// QuicFecBuilderInterface
virtual void OnBuiltFecProtectedPayload(const QuicPacketHeader& header,
- base::StringPiece payload) OVERRIDE;
+ base::StringPiece payload) override;
// Turn on FEC protection for subsequently created packets. FEC should be
// enabled first (max_packets_per_fec_group should be non-zero) for FEC
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index c8d5686..0872762 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -75,7 +75,7 @@
server_framer_.set_visitor(&framer_visitor_);
}
- virtual ~QuicPacketCreatorTest() OVERRIDE {
+ virtual ~QuicPacketCreatorTest() override {
}
void ProcessPacket(QuicPacket* packet) {
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index 703fd64..190e8a7 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -33,7 +33,7 @@
class MockDelegate : public QuicPacketGenerator::DelegateInterface {
public:
MockDelegate() {}
- virtual ~MockDelegate() OVERRIDE {}
+ virtual ~MockDelegate() override {}
MOCK_METHOD3(ShouldGeneratePacket,
bool(TransmissionType transmission_type,
@@ -116,7 +116,7 @@
packet6_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
packet7_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr) {}
- virtual ~QuicPacketGeneratorTest() OVERRIDE {
+ virtual ~QuicPacketGeneratorTest() override {
delete packet_.packet;
delete packet_.retransmittable_frames;
delete packet2_.packet;
diff --git a/net/quic/quic_per_connection_packet_writer.h b/net/quic/quic_per_connection_packet_writer.h
index 9b9b912..4e5e8c8 100644
--- a/net/quic/quic_per_connection_packet_writer.h
+++ b/net/quic/quic_per_connection_packet_writer.h
@@ -32,10 +32,10 @@
virtual WriteResult WritePacket(const char* buffer,
size_t buf_len,
const IPAddressNumber& self_address,
- const IPEndPoint& peer_address) OVERRIDE;
- virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
- virtual bool IsWriteBlocked() const OVERRIDE;
- virtual void SetWritable() OVERRIDE;
+ const IPEndPoint& peer_address) override;
+ virtual bool IsWriteBlockedDataBuffered() const override;
+ virtual bool IsWriteBlocked() const override;
+ virtual void SetWritable() override;
private:
void OnWriteComplete(WriteResult result);
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 6a1bec5..47be63c 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -106,7 +106,7 @@
const QuicStreamId kHeadersStreamId = 3;
// Maximum delayed ack time, in ms.
-const int kMaxDelayedAckTimeMs = 25;
+const int64 kMaxDelayedAckTimeMs = 25;
// The timeout before the handshake succeeds.
const int64 kInitialIdleTimeoutSecs = 5;
@@ -117,6 +117,10 @@
// The default timeout for a connection until the crypto handshake succeeds.
const int64 kMaxTimeForCryptoHandshakeSecs = 10; // 10 secs.
+// Default limit on the number of undecryptable packets the connection buffers
+// before the CHLO/SHLO arrive.
+const size_t kDefaultMaxUndecryptablePackets = 10;
+
// Default ping timeout.
const int64 kPingTimeoutSecs = 15; // 15 secs.
diff --git a/net/quic/quic_received_packet_manager.cc b/net/quic/quic_received_packet_manager.cc
index 255ce4d..187f8e0 100644
--- a/net/quic/quic_received_packet_manager.cc
+++ b/net/quic/quic_received_packet_manager.cc
@@ -167,7 +167,7 @@
uint32 sequence_gap = ack_frame_.largest_observed - sequence_number;
stats_->max_sequence_reordering =
max(stats_->max_sequence_reordering, sequence_gap);
- uint32 reordering_time_us =
+ int64 reordering_time_us =
receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
stats_->max_time_reordering_us = max(stats_->max_time_reordering_us,
reordering_time_us);
@@ -229,14 +229,11 @@
return;
}
- if (approximate_now < time_largest_observed_) {
- // Approximate now may well be "in the past".
- ack_frame->delta_time_largest_observed = QuicTime::Delta::Zero();
- return;
- }
-
+ // Ensure the delta is zero if approximate now is "in the past".
ack_frame->delta_time_largest_observed =
- approximate_now.Subtract(time_largest_observed_);
+ approximate_now < time_largest_observed_ ?
+ QuicTime::Delta::Zero() :
+ approximate_now.Subtract(time_largest_observed_);
// Remove all packets that are too far from largest_observed to express.
received_packet_times_.remove_if(isTooLarge(ack_frame_.largest_observed));
diff --git a/net/quic/quic_received_packet_manager.h b/net/quic/quic_received_packet_manager.h
index 1231891..9eccfe0 100644
--- a/net/quic/quic_received_packet_manager.h
+++ b/net/quic/quic_received_packet_manager.h
@@ -129,7 +129,7 @@
// Called by QuicFramer, when the outgoing ack gets truncated, to recalculate
// the received entropy hash for the truncated ack frame.
virtual QuicPacketEntropyHash EntropyHash(
- QuicPacketSequenceNumber sequence_number) const OVERRIDE;
+ QuicPacketSequenceNumber sequence_number) const override;
// Updates internal state based on |stop_waiting|.
void UpdatePacketInformationSentByPeer(
diff --git a/net/quic/quic_received_packet_manager_test.cc b/net/quic/quic_received_packet_manager_test.cc
index 9e8c128..b64025b 100644
--- a/net/quic/quic_received_packet_manager_test.cc
+++ b/net/quic/quic_received_packet_manager_test.cc
@@ -238,7 +238,7 @@
}
// Reorder by 5 when 2 is received after 7.
EXPECT_EQ(5u, stats_.max_sequence_reordering);
- EXPECT_EQ(0u, stats_.max_time_reordering_us);
+ EXPECT_EQ(0, stats_.max_time_reordering_us);
EXPECT_EQ(2u, stats_.packets_reordered);
}
@@ -285,7 +285,7 @@
// No reordering.
EXPECT_EQ(0u, stats_.max_sequence_reordering);
- EXPECT_EQ(0u, stats_.max_time_reordering_us);
+ EXPECT_EQ(0, stats_.max_time_reordering_us);
EXPECT_EQ(0u, stats_.packets_reordered);
}
@@ -314,6 +314,7 @@
// When UpdateReceivedPacketInfo with a time earlier than the time of the
// largest observed packet, make sure that the delta is 0, not negative.
EXPECT_EQ(QuicTime::Delta::Zero(), ack.delta_time_largest_observed);
+ EXPECT_FALSE(ack.received_packet_times.empty());
QuicTime four_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(4));
received_manager_.UpdateReceivedPacketInfo(&ack, four_ms);
@@ -330,7 +331,7 @@
2, 0, QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(1)));
EXPECT_EQ(4u, stats_.max_sequence_reordering);
- EXPECT_EQ(1000u, stats_.max_time_reordering_us);
+ EXPECT_EQ(1000, stats_.max_time_reordering_us);
EXPECT_EQ(1u, stats_.packets_reordered);
}
diff --git a/net/quic/quic_reliable_client_stream.h b/net/quic/quic_reliable_client_stream.h
index 2d5b818..065db9e 100644
--- a/net/quic/quic_reliable_client_stream.h
+++ b/net/quic/quic_reliable_client_stream.h
@@ -54,10 +54,10 @@
virtual ~QuicReliableClientStream();
// QuicDataStream
- virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
- virtual void OnFinRead() OVERRIDE;
- virtual void OnCanWrite() OVERRIDE;
- virtual QuicPriority EffectivePriority() const OVERRIDE;
+ virtual uint32 ProcessData(const char* data, uint32 data_len) override;
+ virtual void OnFinRead() override;
+ virtual void OnCanWrite() override;
+ virtual QuicPriority EffectivePriority() const override;
// While the server's set_priority shouldn't be called externally, the creator
// of client-side streams should be able to set the priority.
diff --git a/net/quic/quic_sent_packet_manager.cc b/net/quic/quic_sent_packet_manager.cc
index a062827..3e81e74 100644
--- a/net/quic/quic_sent_packet_manager.cc
+++ b/net/quic/quic_sent_packet_manager.cc
@@ -26,17 +26,17 @@
int32 FLAGS_quic_recent_min_rtt_window_s = 60;
namespace {
-static const int kDefaultRetransmissionTimeMs = 500;
+static const int64 kDefaultRetransmissionTimeMs = 500;
// TCP RFC calls for 1 second RTO however Linux differs from this default and
// define the minimum RTO to 200ms, we will use the same until we have data to
// support a higher or lower value.
-static const int kMinRetransmissionTimeMs = 200;
-static const int kMaxRetransmissionTimeMs = 60000;
+static const int64 kMinRetransmissionTimeMs = 200;
+static const int64 kMaxRetransmissionTimeMs = 60000;
static const size_t kMaxRetransmissions = 10;
// Only exponentially back off the handshake timer 5 times due to a timeout.
static const size_t kMaxHandshakeRetransmissionBackoffs = 5;
-static const size_t kMinHandshakeTimeoutMs = 10;
+static const int64 kMinHandshakeTimeoutMs = 10;
// Sends up to two tail loss probes before firing an RTO,
// per draft RFC draft-dukkipati-tcpm-tcp-loss-probe.
@@ -452,7 +452,7 @@
QuicTime::Delta delta_largest_observed) {
QuicPacketSequenceNumber newest_transmission =
info.all_transmissions == nullptr ? sequence_number
- : *info.all_transmissions->rbegin();
+ : *info.all_transmissions->rbegin();
// Remove the most recent packet, if it is pending retransmission.
pending_retransmissions_.erase(newest_transmission);
@@ -503,13 +503,6 @@
DCHECK_LT(0u, sequence_number);
DCHECK(!unacked_packets_.IsUnacked(sequence_number));
LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
- if (debug_delegate_ != nullptr) {
- debug_delegate_->OnSentPacket(*serialized_packet,
- original_sequence_number,
- sent_time,
- bytes,
- transmission_type);
- }
if (original_sequence_number == 0) {
if (serialized_packet->retransmittable_frames) {
@@ -765,7 +758,7 @@
// of (likely, tail) latency, then consider such a mechanism.
const QuicTime::Delta QuicSentPacketManager::DelayedAckTime() const {
return QuicTime::Delta::FromMilliseconds(min(kMaxDelayedAckTimeMs,
- kMinRetransmissionTimeMs/2));
+ kMinRetransmissionTimeMs / 2));
}
const QuicTime QuicSentPacketManager::GetRetransmissionTime() const {
@@ -808,8 +801,9 @@
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<int64>(kMinHandshakeTimeoutMs,
- 1.5 * rtt_stats_.SmoothedRtt().ToMilliseconds());
+ int64 delay_ms =
+ max(kMinHandshakeTimeoutMs,
+ static_cast<int64>(1.5 * rtt_stats_.SmoothedRtt().ToMilliseconds()));
return QuicTime::Delta::FromMilliseconds(
delay_ms << consecutive_crypto_retransmission_count_);
}
@@ -818,8 +812,9 @@
QuicTime::Delta srtt = rtt_stats_.SmoothedRtt();
if (!unacked_packets_.HasMultipleInFlightPackets()) {
return QuicTime::Delta::Max(
- srtt.Multiply(2), srtt.Multiply(1.5)
- .Add(QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs/2)));
+ srtt.Multiply(2),
+ srtt.Multiply(1.5).Add(
+ QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs / 2)));
}
return QuicTime::Delta::FromMilliseconds(
max(kMinTailLossProbeTimeoutMs,
diff --git a/net/quic/quic_sent_packet_manager.h b/net/quic/quic_sent_packet_manager.h
index 2b5f738..f5be3fd 100644
--- a/net/quic/quic_sent_packet_manager.h
+++ b/net/quic/quic_sent_packet_manager.h
@@ -51,13 +51,6 @@
TransmissionType transmission_type,
QuicByteCount byte_size) {}
- virtual void OnSentPacket(
- const SerializedPacket& packet,
- QuicPacketSequenceNumber original_sequence_number,
- QuicTime sent_time,
- QuicByteCount bytes,
- TransmissionType transmission_type) {}
-
virtual void OnIncomingAck(
const QuicAckFrame& ack_frame,
QuicTime ack_receive_time,
diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
index 42c9a6f..3260ab1 100644
--- a/net/quic/quic_sent_packet_manager_test.cc
+++ b/net/quic/quic_sent_packet_manager_test.cc
@@ -63,7 +63,7 @@
EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
}
- virtual ~QuicSentPacketManagerTest() OVERRIDE {
+ virtual ~QuicSentPacketManagerTest() override {
STLDeleteElements(&packets_);
}
diff --git a/net/quic/quic_server_bin.cc b/net/quic/quic_server_bin.cc
index 63b85a7..320f3da 100644
--- a/net/quic/quic_server_bin.cc
+++ b/net/quic/quic_server_bin.cc
@@ -55,15 +55,12 @@
}
base::AtExitManager exit_manager;
-
base::MessageLoopForIO message_loop;
net::IPAddressNumber ip;
CHECK(net::ParseIPLiteralToNumber("::", &ip));
net::QuicConfig config;
- config.SetDefaults();
-
net::QuicServer server(config, net::QuicSupportedVersions());
int rc = server.Listen(net::IPEndPoint(ip, FLAGS_port));
diff --git a/net/quic/quic_server_packet_writer.h b/net/quic/quic_server_packet_writer.h
index 417ea8d..15c946b 100644
--- a/net/quic/quic_server_packet_writer.h
+++ b/net/quic/quic_server_packet_writer.h
@@ -41,16 +41,16 @@
void OnWriteComplete(int rv);
// QuicPacketWriter implementation:
- virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
- virtual bool IsWriteBlocked() const OVERRIDE;
- virtual void SetWritable() OVERRIDE;
+ virtual bool IsWriteBlockedDataBuffered() const override;
+ virtual bool IsWriteBlocked() const override;
+ virtual void SetWritable() override;
protected:
// Do not call WritePacket on its own -- use WritePacketWithCallback
virtual WriteResult WritePacket(const char* buffer,
size_t buf_len,
const IPAddressNumber& self_address,
- const IPEndPoint& peer_address) OVERRIDE;
+ const IPEndPoint& peer_address) override;
private:
UDPServerSocket* socket_;
diff --git a/net/quic/quic_server_session.cc b/net/quic/quic_server_session.cc
index bacd59e..f2967a5 100644
--- a/net/quic/quic_server_session.cc
+++ b/net/quic/quic_server_session.cc
@@ -13,10 +13,9 @@
namespace net {
-QuicServerSession::QuicServerSession(
- const QuicConfig& config,
- QuicConnection* connection,
- QuicServerSessionVisitor* visitor)
+QuicServerSession::QuicServerSession(const QuicConfig& config,
+ QuicConnection* connection,
+ QuicServerSessionVisitor* visitor)
: QuicSession(connection, config),
visitor_(visitor),
bandwidth_estimate_sent_to_client_(QuicBandwidth::Zero()),
@@ -134,7 +133,7 @@
cached_network_params.set_serving_region(serving_region_);
}
- crypto_stream_->SendServerConfigUpdate(&cached_network_params);
+ crypto_stream_->SendServerConfigUpdate(&cached_network_params, false);
last_server_config_update_time_ = now;
}
diff --git a/net/quic/quic_server_session.h b/net/quic/quic_server_session.h
index a2e4feb..80b6443 100644
--- a/net/quic/quic_server_session.h
+++ b/net/quic/quic_server_session.h
@@ -49,12 +49,12 @@
QuicServerSessionVisitor* visitor);
// Override the base class to notify the owner of the connection close.
- virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
- virtual void OnWriteBlocked() OVERRIDE;
+ virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
+ virtual void OnWriteBlocked() override;
// Sends a server config update to the client, containing new bandwidth
// estimate.
- virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE;
+ virtual void OnCongestionWindowChange(QuicTime now) override;
virtual ~QuicServerSession();
@@ -65,7 +65,7 @@
}
// Override base class to process FEC config received from client.
- virtual void OnConfigNegotiated() OVERRIDE;
+ virtual void OnConfigNegotiated() override;
void set_serving_region(string serving_region) {
serving_region_ = serving_region;
@@ -73,9 +73,9 @@
protected:
// QuicSession methods:
- virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
- virtual QuicDataStream* CreateOutgoingDataStream() OVERRIDE;
- virtual QuicCryptoServerStream* GetCryptoStream() OVERRIDE;
+ virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
+ virtual QuicDataStream* CreateOutgoingDataStream() override;
+ virtual QuicCryptoServerStream* GetCryptoStream() override;
// If we should create an incoming stream, returns true. Otherwise
// does error handling, including communicating the error to the client and
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index cef5656..3299e71 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -34,65 +34,65 @@
public:
explicit VisitorShim(QuicSession* session) : session_(session) {}
- virtual void OnStreamFrames(const vector<QuicStreamFrame>& frames) OVERRIDE {
+ virtual void OnStreamFrames(const vector<QuicStreamFrame>& frames) override {
session_->OnStreamFrames(frames);
session_->PostProcessAfterData();
}
- virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
+ virtual void OnRstStream(const QuicRstStreamFrame& frame) override {
session_->OnRstStream(frame);
session_->PostProcessAfterData();
}
- virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE {
+ virtual void OnGoAway(const QuicGoAwayFrame& frame) override {
session_->OnGoAway(frame);
session_->PostProcessAfterData();
}
virtual void OnWindowUpdateFrames(const vector<QuicWindowUpdateFrame>& frames)
- OVERRIDE {
+ override {
session_->OnWindowUpdateFrames(frames);
session_->PostProcessAfterData();
}
virtual void OnBlockedFrames(const vector<QuicBlockedFrame>& frames)
- OVERRIDE {
+ override {
session_->OnBlockedFrames(frames);
session_->PostProcessAfterData();
}
- virtual void OnCanWrite() OVERRIDE {
+ virtual void OnCanWrite() override {
session_->OnCanWrite();
session_->PostProcessAfterData();
}
- virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE {
+ virtual void OnCongestionWindowChange(QuicTime now) override {
session_->OnCongestionWindowChange(now);
}
virtual void OnSuccessfulVersionNegotiation(
- const QuicVersion& version) OVERRIDE {
+ const QuicVersion& version) override {
session_->OnSuccessfulVersionNegotiation(version);
}
virtual void OnConnectionClosed(
- QuicErrorCode error, bool from_peer) OVERRIDE {
+ QuicErrorCode error, bool from_peer) override {
session_->OnConnectionClosed(error, from_peer);
// The session will go away, so don't bother with cleanup.
}
- virtual void OnWriteBlocked() OVERRIDE {
+ virtual void OnWriteBlocked() override {
session_->OnWriteBlocked();
}
- virtual bool WillingAndAbleToWrite() const OVERRIDE {
+ virtual bool WillingAndAbleToWrite() const override {
return session_->WillingAndAbleToWrite();
}
- virtual bool HasPendingHandshake() const OVERRIDE {
+ virtual bool HasPendingHandshake() const override {
return session_->HasPendingHandshake();
}
- virtual bool HasOpenDataStreams() const OVERRIDE {
+ virtual bool HasOpenDataStreams() const override {
return session_->HasOpenDataStreams();
}
@@ -528,12 +528,12 @@
// Inform all existing streams about the new window.
if (connection_->version() >= QUIC_VERSION_21) {
- GetCryptoStream()->flow_controller()->UpdateSendWindowOffset(new_window);
- headers_stream_->flow_controller()->UpdateSendWindowOffset(new_window);
+ GetCryptoStream()->UpdateSendWindowOffset(new_window);
+ headers_stream_->UpdateSendWindowOffset(new_window);
}
for (DataStreamMap::iterator it = stream_map_.begin();
it != stream_map_.end(); ++it) {
- it->second->flow_controller()->UpdateSendWindowOffset(new_window);
+ it->second->UpdateSendWindowOffset(new_window);
}
}
@@ -782,4 +782,22 @@
}
}
+bool QuicSession::IsConnectionFlowControlBlocked() const {
+ return flow_controller_->IsBlocked();
+}
+
+bool QuicSession::IsStreamFlowControlBlocked() {
+ if (headers_stream_->flow_controller()->IsBlocked() ||
+ GetCryptoStream()->flow_controller()->IsBlocked()) {
+ return true;
+ }
+ for (DataStreamMap::iterator it = stream_map_.begin();
+ it != stream_map_.end(); ++it) {
+ if (it->second->flow_controller()->IsBlocked()) {
+ return true;
+ }
+ }
+ return false;
+}
+
} // namespace net
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h
index 7a52fba..6414b6d 100644
--- a/net/quic/quic_session.h
+++ b/net/quic/quic_session.h
@@ -59,22 +59,22 @@
// QuicConnectionVisitorInterface methods:
virtual void OnStreamFrames(
- const std::vector<QuicStreamFrame>& frames) OVERRIDE;
- virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE;
- virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE;
+ const std::vector<QuicStreamFrame>& frames) override;
+ virtual void OnRstStream(const QuicRstStreamFrame& frame) override;
+ virtual void OnGoAway(const QuicGoAwayFrame& frame) override;
virtual void OnWindowUpdateFrames(
- const std::vector<QuicWindowUpdateFrame>& frames) OVERRIDE;
+ const std::vector<QuicWindowUpdateFrame>& frames) override;
virtual void OnBlockedFrames(
- const std::vector<QuicBlockedFrame>& frames) OVERRIDE;
- virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
- virtual void OnWriteBlocked() OVERRIDE {}
+ const std::vector<QuicBlockedFrame>& frames) override;
+ virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
+ virtual void OnWriteBlocked() override {}
virtual void OnSuccessfulVersionNegotiation(
- const QuicVersion& version) OVERRIDE;
- virtual void OnCanWrite() OVERRIDE;
- virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE {}
- virtual bool WillingAndAbleToWrite() const OVERRIDE;
- virtual bool HasPendingHandshake() const OVERRIDE;
- virtual bool HasOpenDataStreams() const OVERRIDE;
+ const QuicVersion& version) override;
+ virtual void OnCanWrite() override;
+ virtual void OnCongestionWindowChange(QuicTime now) override {}
+ virtual bool WillingAndAbleToWrite() const override;
+ virtual bool HasPendingHandshake() const override;
+ virtual bool HasOpenDataStreams() const override;
// Called by the headers stream when headers have been received for a stream.
virtual void OnStreamHeaders(QuicStreamId stream_id,
@@ -206,6 +206,12 @@
QuicFlowController* flow_controller() { return flow_controller_.get(); }
+ // Returns true if connection is flow controller blocked.
+ bool IsConnectionFlowControlBlocked() const;
+
+ // Returns true if any stream is flow controller blocked.
+ bool IsStreamFlowControlBlocked();
+
size_t get_max_open_streams() const { return max_open_streams_; }
protected:
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
index a36b77c..770a564 100644
--- a/net/quic/quic_session_test.cc
+++ b/net/quic/quic_session_test.cc
@@ -9,6 +9,8 @@
#include "base/basictypes.h"
#include "base/containers/hash_tables.h"
+#include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
#include "net/quic/crypto/crypto_protocol.h"
#include "net/quic/quic_crypto_stream.h"
#include "net/quic/quic_flags.h"
@@ -52,7 +54,7 @@
}
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE {
+ const CryptoHandshakeMessage& message) override {
encryption_established_ = true;
handshake_confirmed_ = true;
CryptoHandshakeMessage msg;
@@ -91,7 +93,7 @@
using ReliableQuicStream::CloseWriteSide;
- virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
+ virtual uint32 ProcessData(const char* data, uint32 data_len) override {
return data_len;
}
@@ -129,17 +131,17 @@
InitializeSession();
}
- virtual TestCryptoStream* GetCryptoStream() OVERRIDE {
+ virtual TestCryptoStream* GetCryptoStream() override {
return &crypto_stream_;
}
- virtual TestStream* CreateOutgoingDataStream() OVERRIDE {
+ virtual TestStream* CreateOutgoingDataStream() override {
TestStream* stream = new TestStream(GetNextStreamId(), this);
ActivateStream(stream);
return stream;
}
- virtual TestStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE {
+ virtual TestStream* CreateIncomingDataStream(QuicStreamId id) override {
return new TestStream(id, this);
}
@@ -157,7 +159,7 @@
QuicStreamOffset offset,
bool fin,
FecProtection fec_protection,
- QuicAckNotifier::DelegateInterface* ack_notifier_delegate) OVERRIDE {
+ QuicAckNotifier::DelegateInterface* ack_notifier_delegate) override {
// Always consumes everything.
if (writev_consumes_all_data_) {
return QuicConsumedData(data.TotalBufferSize(), fin);
@@ -534,6 +536,8 @@
// Ensure connection level flow control blockage.
QuicFlowControllerPeer::SetSendWindowOffset(session_.flow_controller(), 0);
EXPECT_TRUE(session_.flow_controller()->IsBlocked());
+ EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
// Mark the crypto and headers streams as write blocked, we expect them to be
// allowed to write later.
@@ -579,11 +583,11 @@
TEST_P(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
EXPECT_EQ((FLAGS_quic_unified_timeouts ?
- kInitialIdleTimeoutSecs : kDefaultIdleTimeoutSecs) + 1,
+ kInitialIdleTimeoutSecs : kDefaultIdleTimeoutSecs) + 3,
QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
CryptoHandshakeMessage msg;
session_.GetCryptoStream()->OnHandshakeMessage(msg);
- EXPECT_EQ(kMaximumIdleTimeoutSecs + 1,
+ EXPECT_EQ(kMaximumIdleTimeoutSecs + 3,
QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
}
@@ -641,9 +645,16 @@
TestStream* stream2 = session_.CreateOutgoingDataStream();
string body(kDefaultFlowControlSendWindow, '.');
EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
stream2->SendBody(body, false);
EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
+ EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
+ // The handshake message will call OnCanWrite, so the stream can resume
+ // writing.
+ EXPECT_CALL(*stream2, OnCanWrite());
// Now complete the crypto handshake, resulting in an increased flow control
// send window.
CryptoHandshakeMessage msg;
@@ -651,6 +662,103 @@
// Stream is now unblocked.
EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+}
+
+TEST_P(QuicSessionTest, HandshakeUnblocksFlowControlBlockedCryptoStream) {
+ if (version() <= QUIC_VERSION_19) {
+ return;
+ }
+ // Test that if the crypto stream is flow control blocked, then if the SHLO
+ // contains a larger send window offset, the stream becomes unblocked.
+ session_.set_writev_consumes_all_data(true);
+ TestCryptoStream* crypto_stream = session_.GetCryptoStream();
+ EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ QuicHeadersStream* headers_stream =
+ QuicSessionPeer::GetHeadersStream(&session_);
+ EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ // Write until the crypto stream is flow control blocked.
+ int i = 0;
+ while (!crypto_stream->flow_controller()->IsBlocked() && i < 1000) {
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ QuicConfig config;
+ CryptoHandshakeMessage crypto_message;
+ config.ToHandshakeMessage(&crypto_message);
+ crypto_stream->SendHandshakeMessage(crypto_message);
+ ++i;
+ }
+ EXPECT_TRUE(crypto_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
+ EXPECT_FALSE(session_.HasDataToWrite());
+ EXPECT_TRUE(crypto_stream->HasBufferedData());
+
+ // The handshake message will call OnCanWrite, so the stream can
+ // resume writing.
+ EXPECT_CALL(*crypto_stream, OnCanWrite());
+ // Now complete the crypto handshake, resulting in an increased flow control
+ // send window.
+ CryptoHandshakeMessage msg;
+ session_.GetCryptoStream()->OnHandshakeMessage(msg);
+
+ // Stream is now unblocked and will no longer have buffered data.
+ EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+}
+
+TEST_P(QuicSessionTest, HandshakeUnblocksFlowControlBlockedHeadersStream) {
+ if (version() <= QUIC_VERSION_19) {
+ return;
+ }
+ // Test that if the header stream is flow control blocked, then if the SHLO
+ // contains a larger send window offset, the stream becomes unblocked.
+ session_.set_writev_consumes_all_data(true);
+ TestCryptoStream* crypto_stream = session_.GetCryptoStream();
+ EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ QuicHeadersStream* headers_stream =
+ QuicSessionPeer::GetHeadersStream(&session_);
+ EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ QuicStreamId stream_id = 5;
+ // Write until the header stream is flow control blocked.
+ while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ SpdyHeaderBlock headers;
+ headers["header"] = base::Uint64ToString(base::RandUint64()) +
+ base::Uint64ToString(base::RandUint64()) +
+ base::Uint64ToString(base::RandUint64());
+ headers_stream->WriteHeaders(stream_id, headers, true, nullptr);
+ stream_id += 2;
+ }
+ EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
+ EXPECT_FALSE(session_.HasDataToWrite());
+ EXPECT_TRUE(headers_stream->HasBufferedData());
+
+ // Now complete the crypto handshake, resulting in an increased flow control
+ // send window.
+ CryptoHandshakeMessage msg;
+ session_.GetCryptoStream()->OnHandshakeMessage(msg);
+
+ // Stream is now unblocked and will no longer have buffered data.
+ EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+ EXPECT_FALSE(headers_stream->HasBufferedData());
}
TEST_P(QuicSessionTest, InvalidFlowControlWindowInHandshake) {
@@ -906,6 +1014,8 @@
QuicFlowControllerPeer::SetSendWindowOffset(headers_stream->flow_controller(),
0);
EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
// Unblock the headers stream by supplying a WINDOW_UPDATE.
QuicWindowUpdateFrame window_update_frame(headers_stream->id(),
@@ -914,6 +1024,8 @@
frames.push_back(window_update_frame);
session_.OnWindowUpdateFrames(frames);
EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+ EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+ EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
}
TEST_P(QuicSessionTest, TooManyUnfinishedStreamsCauseConnectionClose) {
diff --git a/net/quic/quic_spdy_server_stream.h b/net/quic/quic_spdy_server_stream.h
index 3cecb6b..afd1291 100644
--- a/net/quic/quic_spdy_server_stream.h
+++ b/net/quic/quic_spdy_server_stream.h
@@ -31,8 +31,8 @@
// ReliableQuicStream implementation called by the session when there's
// data for us.
- virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
- virtual void OnFinRead() OVERRIDE;
+ virtual uint32 ProcessData(const char* data, uint32 data_len) override;
+ virtual void OnFinRead() override;
void ParseRequestHeaders();
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index ccbca64..687ea4c 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -70,6 +70,8 @@
const int32 kServerSecureInitialCongestionWindow = 32;
// Be conservative, and just use double a typical TCP ICWND for HTTP.
const int32 kServerInecureInitialCongestionWindow = 20;
+// Set the maximum number of undecryptable packets the connection will store.
+const int32 kMaxUndecryptablePackets = 100;
const char kDummyHostname[] = "quic.global.props";
const uint16 kDummyPort = 0;
@@ -90,7 +92,6 @@
QuicConfig InitializeQuicConfig(const QuicTagVector& connection_options) {
QuicConfig config;
- config.SetDefaults();
config.SetIdleConnectionStateLifetime(
QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds),
QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds));
@@ -104,7 +105,7 @@
: socket_(socket) {}
virtual ~DefaultPacketWriterFactory() {}
- virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+ virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
private:
DatagramClientSocket* socket_;
@@ -511,7 +512,6 @@
check_persisted_supports_quic_(true),
weak_factory_(this) {
DCHECK(transport_security_state_);
- crypto_config_.SetDefaults();
crypto_config_.set_user_agent_id(user_agent_id);
crypto_config_.AddCanonicalSuffix(".c.youtube.com");
crypto_config_.AddCanonicalSuffix(".googlevideo.com");
@@ -902,6 +902,7 @@
config.SetInitialCongestionWindowToSend(
server_id.is_https() ? kServerSecureInitialCongestionWindow
: kServerInecureInitialCongestionWindow);
+ config.set_max_undecryptable_packets(kMaxUndecryptablePackets);
config.SetInitialFlowControlWindowToSend(kInitialReceiveWindowSize);
config.SetInitialStreamFlowControlWindowToSend(kInitialReceiveWindowSize);
config.SetInitialSessionFlowControlWindowToSend(kInitialReceiveWindowSize);
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index f4aa77e..f962699 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -147,13 +147,13 @@
// Until the servers support roaming, close all connections when the local
// IP address changes.
- virtual void OnIPAddressChanged() OVERRIDE;
+ virtual void OnIPAddressChanged() override;
// CertDatabase::Observer methods:
// We close all sessions when certificate database is changed.
- virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
- virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
+ virtual void OnCertAdded(const X509Certificate* cert) override;
+ virtual void OnCACertChanged(const X509Certificate* cert) override;
bool require_confirmation() const {
return require_confirmation_;
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index c553fe5..8c90c9f 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -44,7 +44,7 @@
const string& details));
MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
MOCK_METHOD0(OnCanWrite, void());
- virtual QuicPriority EffectivePriority() const OVERRIDE {
+ virtual QuicPriority EffectivePriority() const override {
return QuicUtils::HighestPriority();
}
virtual bool IsFlowControlEnabled() const {
diff --git a/net/quic/quic_time_wait_list_manager.cc b/net/quic/quic_time_wait_list_manager.cc
index d1f3419..4e069d5 100644
--- a/net/quic/quic_time_wait_list_manager.cc
+++ b/net/quic/quic_time_wait_list_manager.cc
@@ -41,7 +41,7 @@
QuicTimeWaitListManager* time_wait_list_manager)
: time_wait_list_manager_(time_wait_list_manager) {}
- virtual QuicTime OnAlarm() OVERRIDE {
+ virtual QuicTime OnAlarm() override {
time_wait_list_manager_->CleanUpOldConnectionIds();
// Let the time wait manager register the alarm at appropriate time.
return QuicTime::Zero();
diff --git a/net/quic/quic_time_wait_list_manager.h b/net/quic/quic_time_wait_list_manager.h
index 4d7b0c5..13544b7 100644
--- a/net/quic/quic_time_wait_list_manager.h
+++ b/net/quic/quic_time_wait_list_manager.h
@@ -79,7 +79,7 @@
// Called by the dispatcher when the underlying socket becomes writable again,
// since we might need to send pending public reset packets which we didn't
// send because the underlying socket was write blocked.
- virtual void OnCanWrite() OVERRIDE;
+ virtual void OnCanWrite() override;
// Used to delete connection_id entries that have outlived their time wait
// period.
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index a10b0ab..a65203b 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -81,7 +81,7 @@
int num_retransmitted_packets,
int num_retransmitted_bytes,
QuicTime::Delta delta_largest_observed)
- OVERRIDE {
+ override {
DCHECK_LT(0, pending_acks_);
--pending_acks_;
num_original_packets_ += num_original_packets;
@@ -106,7 +106,7 @@
protected:
// Delegates are ref counted.
- virtual ~ProxyAckNotifierDelegate() OVERRIDE {
+ virtual ~ProxyAckNotifierDelegate() override {
}
private:
@@ -479,7 +479,6 @@
DLOG(DFATAL) << "Flow control not enabled! " << version();
return;
}
-
if (flow_controller_.UpdateSendWindowOffset(frame.byte_offset)) {
// We can write again!
// TODO(rjshade): This does not respect priorities (e.g. multiple
@@ -533,6 +532,12 @@
}
}
+void ReliableQuicStream::UpdateSendWindowOffset(uint64 new_window) {
+ if (flow_controller_.UpdateSendWindowOffset(new_window)) {
+ OnCanWrite();
+ }
+}
+
bool ReliableQuicStream::IsFlowControlBlocked() {
if (flow_controller_.IsBlocked()) {
return true;
diff --git a/net/quic/reliable_quic_stream.h b/net/quic/reliable_quic_stream.h
index 5b5ae0f..24bc349 100644
--- a/net/quic/reliable_quic_stream.h
+++ b/net/quic/reliable_quic_stream.h
@@ -111,6 +111,10 @@
// WINDOW_UPDATE frame.
void AddBytesConsumed(uint64 bytes);
+ // Updates the flow controller's send window offset and calls OnCanWrite if
+ // it was blocked before.
+ void UpdateSendWindowOffset(uint64 new_offset);
+
// Returns true if the stream is flow control blocked, by the stream flow
// control window or the connection flow control window.
bool IsFlowControlBlocked();
@@ -123,6 +127,9 @@
return fin_received_ || rst_received_;
}
+ // Returns true if the stream has queued data waiting to write.
+ bool HasBufferedData() const;
+
protected:
// Sends as much of 'data' to the connection as the connection will consume,
// and then buffers any remaining data in queued_data_.
@@ -151,8 +158,6 @@
// Close the write side of the socket. Further writes will fail.
void CloseWriteSide();
- bool HasBufferedData() const;
-
bool fin_buffered() const { return fin_buffered_; }
const QuicSession* session() const { return session_; }
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 336ea53..713d0e3 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -48,14 +48,14 @@
: ReliableQuicStream(id, session),
should_process_data_(should_process_data) {}
- virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE {
+ virtual uint32 ProcessRawData(const char* data, uint32 data_len) override {
EXPECT_NE(0u, data_len);
DVLOG(1) << "ProcessData data_len: " << data_len;
data_ += string(data, data_len);
return should_process_data_ ? data_len : 0;
}
- virtual QuicPriority EffectivePriority() const OVERRIDE {
+ virtual QuicPriority EffectivePriority() const override {
return QuicUtils::HighestPriority();
}
diff --git a/net/quic/test_tools/crypto_test_utils.cc b/net/quic/test_tools/crypto_test_utils.cc
index cf8df9a..9f4dc8b 100644
--- a/net/quic/test_tools/crypto_test_utils.cc
+++ b/net/quic/test_tools/crypto_test_utils.cc
@@ -41,10 +41,10 @@
: error_(false) {
}
- virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
+ virtual void OnError(CryptoFramer* framer) override { error_ = true; }
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE {
+ const CryptoHandshakeMessage& message) override {
messages_.push_back(message);
}
@@ -143,7 +143,7 @@
virtual QuicAsyncStatus GetChannelIDKey(
const string& hostname,
scoped_ptr<ChannelIDKey>* channel_id_key,
- ChannelIDSourceCallback* callback) OVERRIDE {
+ ChannelIDSourceCallback* callback) override {
// Synchronous mode.
if (!callback) {
return sync_source_->GetChannelIDKey(hostname, channel_id_key, nullptr);
@@ -160,7 +160,7 @@
}
// CallbackSource implementation.
- virtual void RunPendingCallbacks() OVERRIDE {
+ virtual void RunPendingCallbacks() override {
if (callback_.get()) {
callback_->Run(&channel_id_key_);
callback_.reset();
@@ -219,8 +219,6 @@
TestClientSession client_session(client_conn, DefaultQuicConfig());
QuicCryptoClientConfig crypto_config;
- client_session.config()->SetDefaults();
- crypto_config.SetDefaults();
if (!options.dont_verify_certs) {
// TODO(wtc): replace this with ProofVerifierForTesting() when we have
// a working ProofSourceForTesting().
@@ -273,7 +271,6 @@
QuicRandom* rand,
QuicConfig* config,
QuicCryptoServerConfig* crypto_config) {
- config->SetDefaults();
QuicCryptoServerConfig::ConfigOptions options;
options.channel_id_enabled = true;
scoped_ptr<CryptoHandshakeMessage> scfg(
@@ -356,12 +353,12 @@
index_(index) {
}
- virtual StringPiece GetCommonHashes() const OVERRIDE {
+ virtual StringPiece GetCommonHashes() const override {
CHECK(false) << "not implemented";
return StringPiece();
}
- virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
+ virtual StringPiece GetCert(uint64 hash, uint32 index) const override {
if (hash == hash_ && index == index_) {
return cert_;
}
@@ -371,7 +368,7 @@
virtual bool MatchCert(StringPiece cert,
StringPiece common_set_hashes,
uint64* out_hash,
- uint32* out_index) const OVERRIDE {
+ uint32* out_index) const override {
if (cert != cert_) {
return false;
}
diff --git a/net/quic/test_tools/crypto_test_utils_chromium.cc b/net/quic/test_tools/crypto_test_utils_chromium.cc
index e475e56..d5edc6c 100644
--- a/net/quic/test_tools/crypto_test_utils_chromium.cc
+++ b/net/quic/test_tools/crypto_test_utils_chromium.cc
@@ -59,7 +59,7 @@
const std::string& server_config,
bool ecdsa_ok,
const std::vector<std::string>** out_certs,
- std::string* out_signature) OVERRIDE {
+ std::string* out_signature) override {
*out_certs = &certs_;
*out_signature = kSignature;
return true;
@@ -84,7 +84,7 @@
const ProofVerifyContext* verify_context,
std::string* error_details,
scoped_ptr<ProofVerifyDetails>* verify_details,
- ProofVerifierCallback* callback) OVERRIDE {
+ ProofVerifierCallback* callback) override {
error_details->clear();
scoped_ptr<ProofVerifyDetailsChromium> verify_details_chromium(
new ProofVerifyDetailsChromium);
diff --git a/net/quic/test_tools/crypto_test_utils_nss.cc b/net/quic/test_tools/crypto_test_utils_nss.cc
index eaf0ecd..96fdd31 100644
--- a/net/quic/test_tools/crypto_test_utils_nss.cc
+++ b/net/quic/test_tools/crypto_test_utils_nss.cc
@@ -29,7 +29,7 @@
virtual QuicAsyncStatus GetChannelIDKey(
const string& hostname,
scoped_ptr<ChannelIDKey>* channel_id_key,
- ChannelIDSourceCallback* /*callback*/) OVERRIDE {
+ ChannelIDSourceCallback* /*callback*/) override {
channel_id_key->reset(new ChannelIDKeyChromium(HostnameToKey(hostname)));
return QUIC_SUCCESS;
}
diff --git a/net/quic/test_tools/crypto_test_utils_openssl.cc b/net/quic/test_tools/crypto_test_utils_openssl.cc
index 15babd4..4db57b5 100644
--- a/net/quic/test_tools/crypto_test_utils_openssl.cc
+++ b/net/quic/test_tools/crypto_test_utils_openssl.cc
@@ -26,12 +26,12 @@
class TestChannelIDKey : public ChannelIDKey {
public:
explicit TestChannelIDKey(EVP_PKEY* ecdsa_key) : ecdsa_key_(ecdsa_key) {}
- virtual ~TestChannelIDKey() OVERRIDE {}
+ virtual ~TestChannelIDKey() override {}
// ChannelIDKey implementation.
virtual bool Sign(StringPiece signed_data,
- string* out_signature) const OVERRIDE {
+ string* out_signature) const override {
crypto::ScopedEVP_MD_CTX md_ctx(EVP_MD_CTX_create());
if (!md_ctx ||
EVP_DigestSignInit(md_ctx.get(), nullptr, EVP_sha256(), nullptr,
@@ -75,7 +75,7 @@
return true;
}
- virtual string SerializeKey() const OVERRIDE {
+ virtual string SerializeKey() const override {
// i2d_PublicKey will produce an ANSI X9.62 public key which, for a P-256
// key, is 0x04 (meaning uncompressed) followed by the x and y field
// elements as 32-byte, big-endian numbers.
@@ -106,7 +106,7 @@
virtual QuicAsyncStatus GetChannelIDKey(
const string& hostname,
scoped_ptr<ChannelIDKey>* channel_id_key,
- ChannelIDSourceCallback* /*callback*/) OVERRIDE {
+ ChannelIDSourceCallback* /*callback*/) override {
channel_id_key->reset(new TestChannelIDKey(HostnameToKey(hostname)));
return QUIC_SUCCESS;
}
diff --git a/net/quic/test_tools/delayed_verify_strike_register_client.h b/net/quic/test_tools/delayed_verify_strike_register_client.h
index 6ae7ba1..479647b 100644
--- a/net/quic/test_tools/delayed_verify_strike_register_client.h
+++ b/net/quic/test_tools/delayed_verify_strike_register_client.h
@@ -27,7 +27,7 @@
virtual void VerifyNonceIsValidAndUnique(base::StringPiece nonce,
QuicWallTime now,
- ResultCallback* cb) OVERRIDE;
+ ResultCallback* cb) override;
// Start queueing verifications instead of executing them immediately.
void StartDelayingVerification() {
diff --git a/net/quic/test_tools/mock_clock.h b/net/quic/test_tools/mock_clock.h
index d6e490f..4a2a28c 100644
--- a/net/quic/test_tools/mock_clock.h
+++ b/net/quic/test_tools/mock_clock.h
@@ -20,11 +20,11 @@
void AdvanceTime(QuicTime::Delta delta);
- virtual QuicTime Now() const OVERRIDE;
+ virtual QuicTime Now() const override;
- virtual QuicTime ApproximateNow() const OVERRIDE;
+ virtual QuicTime ApproximateNow() const override;
- virtual QuicWallTime WallNow() const OVERRIDE;
+ virtual QuicWallTime WallNow() const override;
base::TimeTicks NowInTicks() const;
diff --git a/net/quic/test_tools/mock_crypto_client_stream.h b/net/quic/test_tools/mock_crypto_client_stream.h
index e940a1e..10803e8 100644
--- a/net/quic/test_tools/mock_crypto_client_stream.h
+++ b/net/quic/test_tools/mock_crypto_client_stream.h
@@ -46,10 +46,10 @@
// CryptoFramerVisitorInterface implementation.
virtual void OnHandshakeMessage(
- const CryptoHandshakeMessage& message) OVERRIDE;
+ const CryptoHandshakeMessage& message) override;
// QuicCryptoClientStream implementation.
- virtual bool CryptoConnect() OVERRIDE;
+ virtual bool CryptoConnect() override;
// Invokes the sessions's CryptoHandshakeEvent method with the specified
// event.
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.h b/net/quic/test_tools/mock_crypto_client_stream_factory.h
index 721ec25..5add188 100644
--- a/net/quic/test_tools/mock_crypto_client_stream_factory.h
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.h
@@ -23,7 +23,7 @@
virtual QuicCryptoClientStream* CreateQuicCryptoClientStream(
const QuicServerId& server_id,
QuicClientSession* session,
- QuicCryptoClientConfig* crypto_config) OVERRIDE;
+ QuicCryptoClientConfig* crypto_config) override;
void set_handshake_mode(
MockCryptoClientStream::HandshakeMode handshake_mode) {
diff --git a/net/quic/test_tools/mock_random.h b/net/quic/test_tools/mock_random.h
index 53b24b7..b04f170 100644
--- a/net/quic/test_tools/mock_random.h
+++ b/net/quic/test_tools/mock_random.h
@@ -18,12 +18,12 @@
// QuicRandom:
// Fills the |data| buffer with a repeating byte, initially 'r'.
- virtual void RandBytes(void* data, size_t len) OVERRIDE;
+ virtual void RandBytes(void* data, size_t len) override;
// Returns base + the current increment.
- virtual uint64 RandUint64() OVERRIDE;
+ virtual uint64 RandUint64() override;
// Does nothing.
virtual void Reseed(const void* additional_entropy,
- size_t entropy_len) OVERRIDE;
+ size_t entropy_len) override;
// ChangeValue increments |increment_|. This causes the value returned by
// |RandUint64| and the byte that |RandBytes| fills with, to change.
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index 0cf13e1..6cdd02a 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -37,8 +37,8 @@
: QuicAlarm(delegate) {
}
- virtual void SetImpl() OVERRIDE {}
- virtual void CancelImpl() OVERRIDE {}
+ virtual void SetImpl() override {}
+ virtual void CancelImpl() override {}
};
} // namespace
@@ -229,7 +229,7 @@
virtual ~NiceMockPacketWriterFactory() {}
virtual QuicPacketWriter* Create(
- QuicConnection* /*connection*/) const OVERRIDE {
+ QuicConnection* /*connection*/) const override {
return new testing::NiceMock<MockPacketWriter>();
}
@@ -609,7 +609,6 @@
QuicConfig DefaultQuicConfig() {
QuicConfig config;
- config.SetDefaults();
config.SetInitialFlowControlWindowToSend(
kInitialSessionFlowControlWindowForTest);
config.SetInitialStreamFlowControlWindowToSend(
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 4c57a9b..f009641 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -190,35 +190,35 @@
public:
NoOpFramerVisitor() {}
- virtual void OnError(QuicFramer* framer) OVERRIDE {}
- virtual void OnPacket() OVERRIDE {}
+ virtual void OnError(QuicFramer* framer) override {}
+ virtual void OnPacket() override {}
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& packet) OVERRIDE {}
+ const QuicPublicResetPacket& packet) override {}
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) OVERRIDE {}
- virtual void OnRevivedPacket() OVERRIDE {}
- virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
- virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
+ const QuicVersionNegotiationPacket& packet) override {}
+ virtual void OnRevivedPacket() override {}
+ virtual bool OnProtocolVersionMismatch(QuicVersion version) override;
+ virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) OVERRIDE;
- virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
- virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
- virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
- virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
- virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+ const QuicPacketPublicHeader& header) override;
+ virtual void OnDecryptedPacket(EncryptionLevel level) override {}
+ virtual bool OnPacketHeader(const QuicPacketHeader& header) override;
+ virtual void OnFecProtectedPayload(base::StringPiece payload) override {}
+ virtual bool OnStreamFrame(const QuicStreamFrame& frame) override;
+ virtual bool OnAckFrame(const QuicAckFrame& frame) override;
virtual bool OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) OVERRIDE;
+ const QuicCongestionFeedbackFrame& frame) override;
virtual bool OnStopWaitingFrame(
- const QuicStopWaitingFrame& frame) OVERRIDE;
- virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
- virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+ const QuicStopWaitingFrame& frame) override;
+ virtual bool OnPingFrame(const QuicPingFrame& frame) override;
+ virtual void OnFecData(const QuicFecData& fec) override {}
+ virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) OVERRIDE;
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
- virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
- virtual void OnPacketComplete() OVERRIDE {}
+ const QuicConnectionCloseFrame& frame) override;
+ virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+ virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+ virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+ virtual void OnPacketComplete() override {}
private:
DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
@@ -255,9 +255,9 @@
public:
MockHelper();
virtual ~MockHelper();
- virtual const QuicClock* GetClock() const OVERRIDE;
- virtual QuicRandom* GetRandomGenerator() OVERRIDE;
- virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE;
+ virtual const QuicClock* GetClock() const override;
+ virtual QuicRandom* GetRandomGenerator() override;
+ virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
void AdvanceTime(QuicTime::Delta delta);
private:
@@ -312,7 +312,7 @@
QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
}
- virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+ virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
return false;
}
@@ -331,7 +331,7 @@
virtual ~PacketSavingConnection();
- virtual void SendOrQueuePacket(QueuedPacket packet) OVERRIDE;
+ virtual void SendOrQueuePacket(QueuedPacket packet) override;
std::vector<QuicPacket*> packets_;
std::vector<QuicEncryptedPacket*> encrypted_packets_;
@@ -383,7 +383,7 @@
void SetCryptoStream(QuicCryptoStream* stream);
- virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+ virtual QuicCryptoStream* GetCryptoStream() override;
private:
QuicCryptoStream* crypto_stream_;
@@ -408,7 +408,7 @@
void SetCryptoStream(QuicCryptoStream* stream);
- virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+ virtual QuicCryptoStream* GetCryptoStream() override;
private:
QuicCryptoStream* crypto_stream_;
@@ -496,7 +496,7 @@
virtual ~TestEntropyCalculator();
virtual QuicPacketEntropyHash EntropyHash(
- QuicPacketSequenceNumber sequence_number) const OVERRIDE;
+ QuicPacketSequenceNumber sequence_number) const override;
private:
DISALLOW_COPY_AND_ASSIGN(TestEntropyCalculator);
@@ -554,7 +554,7 @@
virtual ~TestWriterFactory();
virtual QuicPacketWriter* Create(QuicServerPacketWriter* writer,
- QuicConnection* connection) OVERRIDE;
+ QuicConnection* connection) override;
// Calls OnPacketSent on the last QuicConnection to write through one of the
// packet writers created by this factory.
@@ -572,7 +572,7 @@
const char* buffer,
size_t buf_len,
const IPAddressNumber& self_address,
- const IPEndPoint& peer_address) OVERRIDE;
+ const IPEndPoint& peer_address) override;
private:
TestWriterFactory* factory_;
diff --git a/net/quic/test_tools/simple_quic_framer.cc b/net/quic/test_tools/simple_quic_framer.cc
index a08d555..6999cf5 100644
--- a/net/quic/test_tools/simple_quic_framer.cc
+++ b/net/quic/test_tools/simple_quic_framer.cc
@@ -22,48 +22,48 @@
: error_(QUIC_NO_ERROR) {
}
- virtual ~SimpleFramerVisitor() OVERRIDE {
+ virtual ~SimpleFramerVisitor() override {
STLDeleteElements(&stream_data_);
}
- virtual void OnError(QuicFramer* framer) OVERRIDE {
+ virtual void OnError(QuicFramer* framer) override {
error_ = framer->error();
}
- virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+ virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
return false;
}
- virtual void OnPacket() OVERRIDE {}
+ virtual void OnPacket() override {}
virtual void OnPublicResetPacket(
- const QuicPublicResetPacket& packet) OVERRIDE {
+ const QuicPublicResetPacket& packet) override {
public_reset_packet_.reset(new QuicPublicResetPacket(packet));
}
virtual void OnVersionNegotiationPacket(
- const QuicVersionNegotiationPacket& packet) OVERRIDE {
+ const QuicVersionNegotiationPacket& packet) override {
version_negotiation_packet_.reset(
new QuicVersionNegotiationPacket(packet));
}
- virtual void OnRevivedPacket() OVERRIDE {}
+ virtual void OnRevivedPacket() override {}
virtual bool OnUnauthenticatedPublicHeader(
- const QuicPacketPublicHeader& header) OVERRIDE {
+ const QuicPacketPublicHeader& header) override {
return true;
}
virtual bool OnUnauthenticatedHeader(
- const QuicPacketHeader& header) OVERRIDE {
+ const QuicPacketHeader& header) override {
return true;
}
- virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
- virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
+ virtual void OnDecryptedPacket(EncryptionLevel level) override {}
+ virtual bool OnPacketHeader(const QuicPacketHeader& header) override {
has_header_ = true;
header_ = header;
return true;
}
- virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {}
+ virtual void OnFecProtectedPayload(StringPiece payload) override {}
- virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
+ virtual bool OnStreamFrame(const QuicStreamFrame& frame) override {
// Save a copy of the data so it is valid after the packet is processed.
stream_data_.push_back(frame.GetDataAsString());
QuicStreamFrame stream_frame(frame);
@@ -75,61 +75,61 @@
return true;
}
- virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
+ virtual bool OnAckFrame(const QuicAckFrame& frame) override {
ack_frames_.push_back(frame);
return true;
}
virtual bool OnCongestionFeedbackFrame(
- const QuicCongestionFeedbackFrame& frame) OVERRIDE {
+ const QuicCongestionFeedbackFrame& frame) override {
feedback_frames_.push_back(frame);
return true;
}
- virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+ virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
stop_waiting_frames_.push_back(frame);
return true;
}
- virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
+ virtual bool OnPingFrame(const QuicPingFrame& frame) override {
ping_frames_.push_back(frame);
return true;
}
- virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
+ virtual void OnFecData(const QuicFecData& fec) override {
fec_data_ = fec;
fec_redundancy_ = fec_data_.redundancy.as_string();
fec_data_.redundancy = fec_redundancy_;
}
- virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
+ virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
rst_stream_frames_.push_back(frame);
return true;
}
virtual bool OnConnectionCloseFrame(
- const QuicConnectionCloseFrame& frame) OVERRIDE {
+ const QuicConnectionCloseFrame& frame) override {
connection_close_frames_.push_back(frame);
return true;
}
- virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
+ virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
goaway_frames_.push_back(frame);
return true;
}
virtual bool OnWindowUpdateFrame(
- const QuicWindowUpdateFrame& frame) OVERRIDE {
+ const QuicWindowUpdateFrame& frame) override {
window_update_frames_.push_back(frame);
return true;
}
- virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+ virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
blocked_frames_.push_back(frame);
return true;
}
- virtual void OnPacketComplete() OVERRIDE {}
+ virtual void OnPacketComplete() override {}
const QuicPacketHeader& header() const { return header_; }
const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
diff --git a/net/quic/test_tools/test_task_runner.h b/net/quic/test_tools/test_task_runner.h
index e25bf2a..ea6793f 100644
--- a/net/quic/test_tools/test_task_runner.h
+++ b/net/quic/test_tools/test_task_runner.h
@@ -28,8 +28,8 @@
// base::TaskRunner implementation.
virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
const base::Closure& task,
- base::TimeDelta delay) OVERRIDE;
- virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+ base::TimeDelta delay) override;
+ virtual bool RunsTasksOnCurrentThread() const override;
const std::vector<PostedTask>& GetPostedTasks() const;
