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;