Tell congestion manager when we are sending a CHLO, so it won't delay sending.

Most critically, we need to ignore the congestion window when we're sending a CHLO. Such packets are notable as they are the only packets send with null encryption (other than perhaps ACKs, which are generally not restricted anyway). BUG=266647 Review URL: https://chromiumcodereview.appspot.com/21714002 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@215455 0039d316-1c4b-4281-b951-d872f2087c98
author: jar@chromium.org <jar@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2013-08-03 02:06:43 +0000
committer: jar@chromium.org <jar@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> 2013-08-03 02:06:43 +0000
commit: 575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1 (patch)
tree: 1924938680cb7c579e47fb77f9f6d3c371708325 /net
parent: 36e151a64e36f7f5f491e74995f402ef69e9e81c (diff)
download: chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.zip
chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.tar.gz
chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.tar.bz2
25 files changed, 285 insertions, 250 deletions
diff --git a/net/quic/congestion_control/fix_rate_sender.cc b/net/quic/congestion_control/fix_rate_sender.cc
index cd0923d..dff52cf 100644
--- a/net/quic/congestion_control/fix_rate_sender.cc
+++ b/net/quic/congestion_control/fix_rate_sender.cc
@@ -79,7 +79,8 @@ void FixRateSender::AbandoningPacket(
 QuicTime::Delta FixRateSender::TimeUntilSend(
     QuicTime now,
     Retransmission /*is_retransmission*/,
-    HasRetransmittableData /*has_retransmittable_data*/) {
+    HasRetransmittableData /*has_retransmittable_data*/,
+    IsHandshake /* handshake */) {
   if (CongestionWindow() > fix_rate_leaky_bucket_.BytesPending(now)) {
     if (CongestionWindow() <= data_in_flight_) {
       // We need an ack before we send more.
diff --git a/net/quic/congestion_control/fix_rate_sender.h b/net/quic/congestion_control/fix_rate_sender.h
index 251ab39..38cebad1 100644
--- a/net/quic/congestion_control/fix_rate_sender.h
+++ b/net/quic/congestion_control/fix_rate_sender.h
@@ -41,7 +41,8 @@ class NET_EXPORT_PRIVATE FixRateSender : public SendAlgorithmInterface {
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       Retransmission is_retransmission,
-      HasRetransmittableData has_retransmittable_data) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data,
+      IsHandshake handshake) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() OVERRIDE;
   virtual QuicTime::Delta SmoothedRtt() OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() OVERRIDE;
diff --git a/net/quic/congestion_control/fix_rate_test.cc b/net/quic/congestion_control/fix_rate_test.cc
index b772d01..f914ed6 100644
--- a/net/quic/congestion_control/fix_rate_test.cc
+++ b/net/quic/congestion_control/fix_rate_test.cc
@@ -8,8 +8,8 @@
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/fix_rate_receiver.h"
 #include "net/quic/congestion_control/fix_rate_sender.h"
-#include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/test_tools/mock_clock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -61,24 +61,25 @@ TEST_F(FixRateTest, SenderAPI) {
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback,  clock_.Now(),
                                                  unused_packet_map_);
   EXPECT_EQ(300000, sender_->BandwidthEstimate().ToBytesPerSecond());
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   sender_->SentPacket(clock_.Now(), 1, kMaxPacketSize, NOT_RETRANSMISSION);
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   sender_->SentPacket(clock_.Now(), 2, kMaxPacketSize, NOT_RETRANSMISSION);
   sender_->SentPacket(clock_.Now(), 3, 600, NOT_RETRANSMISSION);
-  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10), sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10),
+      sender_->TimeUntilSend(clock_.Now(),
+          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
-  EXPECT_EQ(QuicTime::Delta::Infinite(), sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+  EXPECT_EQ(QuicTime::Delta::Infinite(), sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8));
   sender_->OnIncomingAck(1, kMaxPacketSize, rtt_);
   sender_->OnIncomingAck(2, kMaxPacketSize, rtt_);
   sender_->OnIncomingAck(3, 600, rtt_);
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 }
 
 TEST_F(FixRateTest, FixRatePacing) {
@@ -93,16 +94,18 @@ TEST_F(FixRateTest, FixRatePacing) {
   QuicTime acc_advance_time(QuicTime::Zero());
   QuicPacketSequenceNumber sequence_number = 0;
   for (int i = 0; i < num_packets; i += 2) {
-    EXPECT_TRUE(sender_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
+         NOT_HANDSHAKE).IsZero());
     sender_->SentPacket(clock_.Now(), sequence_number++, packet_size,
                         NOT_RETRANSMISSION);
-    EXPECT_TRUE(sender_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
+        NOT_HANDSHAKE).IsZero());
     sender_->SentPacket(clock_.Now(), sequence_number++, packet_size,
                         NOT_RETRANSMISSION);
-    QuicTime::Delta advance_time = sender_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta advance_time = sender_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     sender_->OnIncomingAck(sequence_number - 1, packet_size, rtt_);
     sender_->OnIncomingAck(sequence_number - 2, packet_size, rtt_);
diff --git a/net/quic/congestion_control/inter_arrival_sender.cc b/net/quic/congestion_control/inter_arrival_sender.cc
index 07421ae..1aa7ab9 100644
--- a/net/quic/congestion_control/inter_arrival_sender.cc
+++ b/net/quic/congestion_control/inter_arrival_sender.cc
@@ -257,7 +257,8 @@ void InterArrivalSender::AbandoningPacket(
 QuicTime::Delta InterArrivalSender::TimeUntilSend(
     QuicTime now,
     Retransmission /*retransmit*/,
-    HasRetransmittableData has_retransmittable_data) {
+    HasRetransmittableData has_retransmittable_data,
+    IsHandshake /* handshake */) {
   // TODO(pwestin): implement outer_congestion_window_ logic.
   QuicTime::Delta outer_window = QuicTime::Delta::Zero();
 
diff --git a/net/quic/congestion_control/inter_arrival_sender.h b/net/quic/congestion_control/inter_arrival_sender.h
index 9889c0d..ad28ecd 100644
--- a/net/quic/congestion_control/inter_arrival_sender.h
+++ b/net/quic/congestion_control/inter_arrival_sender.h
@@ -54,7 +54,8 @@ class NET_EXPORT_PRIVATE InterArrivalSender : public SendAlgorithmInterface {
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       Retransmission is_retransmission,
-      HasRetransmittableData has_retransmittable_data) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data,
+      IsHandshake handshake) OVERRIDE;
 
   virtual QuicBandwidth BandwidthEstimate() OVERRIDE;
   virtual QuicTime::Delta SmoothedRtt() OVERRIDE;
diff --git a/net/quic/congestion_control/inter_arrival_sender_test.cc b/net/quic/congestion_control/inter_arrival_sender_test.cc
index e44be09..d0faca0 100644
--- a/net/quic/congestion_control/inter_arrival_sender_test.cc
+++ b/net/quic/congestion_control/inter_arrival_sender_test.cc
@@ -33,8 +33,8 @@ class InterArrivalSenderTest : public ::testing::Test {
   }
 
   void SendAvailableCongestionWindow() {
-    while (sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                 HAS_RETRANSMITTABLE_DATA).IsZero()) {
+    while (sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero()) {
       QuicByteCount bytes_in_packet = kMaxPacketSize;
       sent_packets_[sequence_number_] =
           new class SendAlgorithmInterface::SentPacket(
@@ -44,8 +44,8 @@ class InterArrivalSenderTest : public ::testing::Test {
                          NOT_RETRANSMISSION);
       sequence_number_++;
     }
-    EXPECT_FALSE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                       HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_FALSE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
 
   void AckNPackets(int n) {
@@ -119,29 +119,29 @@ class InterArrivalSenderTest : public ::testing::Test {
 TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsInfinite());
+      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -153,11 +153,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we move fast in the beginning.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -168,11 +168,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we slow down towards the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -183,11 +183,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we move very slow close to the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -199,11 +199,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we move very slow close to the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -215,11 +215,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we move very slow close to the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -230,11 +230,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we accelerate after the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -245,11 +245,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send 50 bursts, make sure that we accelerate after the probe rate.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -265,11 +265,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send until we reach halfway point.
   for (int i = 0; i < 570; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -281,11 +281,11 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
   // Send until we reach max channel capacity.
   for (int i = 0; i < 1500; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -297,29 +297,29 @@ TEST_F(InterArrivalSenderTest, ProbeFollowedByFullRampUpCycle) {
 TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsInfinite());
+      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -331,11 +331,11 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   // Send 50 bursts, make sure that we move fast in the beginning.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -344,10 +344,10 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 600, 10);
 
   SendAvailableCongestionWindow();
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   AckNPackets(2);
 
   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
@@ -362,10 +362,10 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   // Run until we are catched up after our introduced delay spike.
   while (send_clock_.Now() < receive_clock_.Now()) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, one_ms_);
   }
@@ -378,11 +378,11 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   // before the spike.
   for (int i = 0; i < 100; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -394,29 +394,29 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
 TEST_F(InterArrivalSenderTest, DelaySpikeFollowedByImmediateDrain) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsInfinite());
+      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -428,11 +428,11 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedByImmediateDrain) {
   // Send 50 bursts, make sure that we move fast in the beginning.
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -441,10 +441,10 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedByImmediateDrain) {
   EXPECT_NEAR(SenderDeltaSinceStart().ToMilliseconds(), 600, 10);
 
   SendAvailableCongestionWindow();
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   AckNPackets(2);
 
   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
@@ -474,16 +474,16 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToDelay) {
   QuicBandwidth expected_min_bitrate = QuicBandwidth::FromKBitsPerSecond(10);
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
   SendAvailableCongestionWindow();
 
@@ -492,10 +492,10 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToDelay) {
   // One second spread per packet is expected to result in an estimate at
   // our minimum bitrate.
   SendFeedbackMessageNPackets(10, one_s_, one_s_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 }
 
@@ -503,25 +503,25 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
   QuicBandwidth expected_min_bitrate = QuicBandwidth::FromKBitsPerSecond(10);
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   // Send 5 bursts.
   for (int i = 0; i < 4; ++i) {
     SendAvailableCongestionWindow();
-    send_clock_.AdvanceTime(sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   }
   SendAvailableCongestionWindow();
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, nine_ms_, nine_ms_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(
-      send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                    HAS_RETRANSMITTABLE_DATA).IsZero());
+  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(81);
   int64 probe_rate = kMaxPacketSize * 9 * kNumMicrosPerSecond /
@@ -531,11 +531,11 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
 
   for (int i = 0; i < 15; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     sender_.OnIncomingLoss(send_clock_.Now());
     sender_.OnIncomingAck(acked_sequence_number_, kMaxPacketSize, rtt_);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
@@ -546,11 +546,11 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
 
   for (int i = 0; i < 50; ++i) {
     SendAvailableCongestionWindow();
-    QuicTime::Delta time_until_send = sender_.TimeUntilSend(
-        send_clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta time_until_send = sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     send_clock_.AdvanceTime(time_until_send);
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-                                      HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     sender_.OnIncomingLoss(send_clock_.Now());
     sender_.OnIncomingAck(acked_sequence_number_, kMaxPacketSize, rtt_);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
diff --git a/net/quic/congestion_control/quic_congestion_control_test.cc b/net/quic/congestion_control/quic_congestion_control_test.cc
index 53e2db8..0051aca 100644
--- a/net/quic/congestion_control/quic_congestion_control_test.cc
+++ b/net/quic/congestion_control/quic_congestion_control_test.cc
@@ -47,20 +47,20 @@ TEST_F(QuicCongestionControlTest, FixedRateSenderAPI) {
   congestion_feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(30);
   manager_->OnIncomingQuicCongestionFeedbackFrame(congestion_feedback,
                                                   clock_.Now());
-  EXPECT_TRUE(manager_->TimeUntilSend(
-    clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   manager_->SentPacket(1, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(40),
-            manager_->TimeUntilSend(
-                clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+            manager_->TimeUntilSend(clock_.Now(),
+                NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(35));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
-            manager_->TimeUntilSend(
-                clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+            manager_->TimeUntilSend(clock_.Now(),
+                NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
-            manager_->TimeUntilSend(
-                clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+            manager_->TimeUntilSend(clock_.Now(),
+                NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
 }
 
 TEST_F(QuicCongestionControlTest, FixedRatePacing) {
@@ -76,11 +76,11 @@ TEST_F(QuicCongestionControlTest, FixedRatePacing) {
 
   QuicTime acc_advance_time(QuicTime::Zero());
   for (QuicPacketSequenceNumber i = 1; i <= 100; ++i) {
-    EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(i, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
-    QuicTime::Delta advance_time = manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packet we sent.
@@ -106,14 +106,14 @@ TEST_F(QuicCongestionControlTest, Pacing) {
 
   QuicTime acc_advance_time(QuicTime::Zero());
   for (QuicPacketSequenceNumber i = 1; i <= 100;) {
-    EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
-    EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+    EXPECT_TRUE(manager_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(i++, clock_.Now(), kMaxPacketSize, NOT_RETRANSMISSION);
-    QuicTime::Delta advance_time = manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta advance_time = manager_->TimeUntilSend(clock_.Now(),
+        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     acc_advance_time = acc_advance_time.Add(advance_time);
     // Ack the packets we sent.
diff --git a/net/quic/congestion_control/quic_congestion_manager.cc b/net/quic/congestion_control/quic_congestion_manager.cc
index 1773c82..838195f 100644
--- a/net/quic/congestion_control/quic_congestion_manager.cc
+++ b/net/quic/congestion_control/quic_congestion_manager.cc
@@ -128,8 +128,10 @@ void QuicCongestionManager::OnIncomingAckFrame(const QuicAckFrame& frame,
 QuicTime::Delta QuicCongestionManager::TimeUntilSend(
     QuicTime now,
     Retransmission retransmission,
-    HasRetransmittableData retransmittable) {
-  return send_algorithm_->TimeUntilSend(now, retransmission, retransmittable);
+    HasRetransmittableData retransmittable,
+    IsHandshake handshake) {
+  return send_algorithm_->TimeUntilSend(now, retransmission, retransmittable,
+                                        handshake);
 }
 
 bool QuicCongestionManager::GenerateCongestionFeedback(
diff --git a/net/quic/congestion_control/quic_congestion_manager.h b/net/quic/congestion_control/quic_congestion_manager.h
index 204209a..8bfa3c1 100644
--- a/net/quic/congestion_control/quic_congestion_manager.h
+++ b/net/quic/congestion_control/quic_congestion_manager.h
@@ -62,7 +62,8 @@ class NET_EXPORT_PRIVATE QuicCongestionManager {
   // calculations.
   virtual QuicTime::Delta TimeUntilSend(QuicTime now,
                                         Retransmission retransmission,
-                                        HasRetransmittableData retransmittable);
+                                        HasRetransmittableData retransmittable,
+                                        IsHandshake handshake);
 
   // Should be called before sending an ACK packet, to decide if we need
   // to attach a QuicCongestionFeedbackFrame block.
diff --git a/net/quic/congestion_control/quic_congestion_manager_test.cc b/net/quic/congestion_control/quic_congestion_manager_test.cc
index 64aab9a..1cf44a2 100644
--- a/net/quic/congestion_control/quic_congestion_manager_test.cc
+++ b/net/quic/congestion_control/quic_congestion_manager_test.cc
@@ -60,10 +60,10 @@ TEST_F(QuicCongestionManagerTest, Bandwidth) {
 
   for (int i = 1; i <= 100; ++i) {
     QuicTime::Delta advance_time = manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, kIgnored);
+        clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE);
     clock_.AdvanceTime(advance_time);
     EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, kIgnored).IsZero());
+        clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(i, clock_.Now(), 1000, NOT_RETRANSMISSION);
     // Ack the packet we sent.
     ack.received_info.largest_observed = i;
@@ -91,7 +91,7 @@ TEST_F(QuicCongestionManagerTest, BandwidthWith1SecondGap) {
       ++sequence_number) {
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
     EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, kIgnored).IsZero());
+        clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(
         sequence_number, clock_.Now(), 1000, NOT_RETRANSMISSION);
     // Ack the packet we sent.
@@ -117,7 +117,7 @@ TEST_F(QuicCongestionManagerTest, BandwidthWith1SecondGap) {
       clock_.Now()).IsZero());
   for (int i = 1; i <= 150; ++i) {
     EXPECT_TRUE(manager_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION, kIgnored).IsZero());
+        clock_.Now(), NOT_RETRANSMISSION, kIgnored, NOT_HANDSHAKE).IsZero());
     manager_->SentPacket(i + 100, clock_.Now(), 1000, NOT_RETRANSMISSION);
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
     // Ack the packet we sent.
diff --git a/net/quic/congestion_control/send_algorithm_interface.h b/net/quic/congestion_control/send_algorithm_interface.h
index 440201c..8896b2b 100644
--- a/net/quic/congestion_control/send_algorithm_interface.h
+++ b/net/quic/congestion_control/send_algorithm_interface.h
@@ -69,7 +69,8 @@ class NET_EXPORT_PRIVATE SendAlgorithmInterface {
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       Retransmission is_retransmission,
-      HasRetransmittableData has_retransmittable_data) = 0;
+      HasRetransmittableData has_retransmittable_data,
+      IsHandshake handshake) = 0;
 
   // What's the current estimated bandwidth in bytes per second.
   // Returns 0 when it does not have an estimate.
diff --git a/net/quic/congestion_control/tcp_cubic_sender.cc b/net/quic/congestion_control/tcp_cubic_sender.cc
index 73c05da..56cc624 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender.cc
@@ -112,10 +112,15 @@ void TcpCubicSender::AbandoningPacket(QuicPacketSequenceNumber sequence_number,
 QuicTime::Delta TcpCubicSender::TimeUntilSend(
     QuicTime now,
     Retransmission is_retransmission,
-    HasRetransmittableData has_retransmittable_data) {
+    HasRetransmittableData has_retransmittable_data,
+    IsHandshake handshake) {
   if (is_retransmission == IS_RETRANSMISSION ||
-      has_retransmittable_data == NO_RETRANSMITTABLE_DATA) {
-    // For TCP we can always send a retransmission and/or an ACK immediately.
+      has_retransmittable_data == NO_RETRANSMITTABLE_DATA ||
+      handshake == IS_HANDSHAKE) {
+    // For TCP we can always send a retransmission,  or an ACK immediately.
+    // We also immediately send any handshake packet (CHLO, etc.).  We provide
+    // this  special dispensation for handshake messages in QUIC, although the
+    // concept is not present in TCP.
     return QuicTime::Delta::Zero();
   }
   if (AvailableCongestionWindow() == 0) {
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index 1774023..de8f9c3 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -48,7 +48,8 @@ class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       Retransmission is_retransmission,
-      HasRetransmittableData has_retransmittable_data) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data,
+      IsHandshake handshake) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() OVERRIDE;
   virtual QuicTime::Delta SmoothedRtt() OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() OVERRIDE;
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 68a8d6b..ecc8f21 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -44,7 +44,7 @@ class TcpCubicSenderTest : public ::testing::Test {
       bytes_to_send -= bytes_in_packet;
       if (bytes_to_send > 0) {
         EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                           HAS_RETRANSMITTABLE_DATA).IsZero());
+                        HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
       }
     }
   }
@@ -73,36 +73,36 @@ TEST_F(TcpCubicSenderTest, SimpleSender) {
   EXPECT_EQ(kDefaultWindowTCP,
             sender_->AvailableCongestionWindow());
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
                                                  not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   // And that window is un-affected.
   EXPECT_EQ(kDefaultWindowTCP, sender_->AvailableCongestionWindow());
 
   // A retransmitt should always retun 0.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), IS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      IS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 }
 
 TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
   const int kNumberOfAck = 20;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
                                                  not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   for (int n = 0; n < kNumberOfAck; ++n) {
     // Send our full congestion window.
@@ -123,15 +123,15 @@ TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
   const int kNumberOfAck = 65;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
                                                  not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   for (int n = 0; n < kNumberOfAck; ++n) {
     // Send our full congestion window.
@@ -166,15 +166,15 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   const int kNumberOfAck = 10;
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
                                                  not_used_);
   // Make sure we can send.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
 
   for (int i = 0; i < kNumberOfAck; ++i) {
     // Send our full congestion window.
@@ -189,8 +189,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   sender_->OnIncomingLoss(clock_.Now());
 
   // Make sure that we should not send right now.
-  EXPECT_TRUE(sender_->TimeUntilSend(
-      clock_.Now(), NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA).IsInfinite());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
+      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
 
   // We should now have fallen out of slow start.
   // We expect window to be cut in half.
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 099f9d5..4badfa7 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -375,7 +375,7 @@ bool QuicConnection::OnAckFrame(const QuicAckFrame& incoming_ack) {
   // queued locally, or drain streams which are blocked.
   QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
       time_of_last_received_packet_, NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA);
+      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
   if (delay.IsZero()) {
     helper_->UnregisterSendAlarmIfRegistered();
     WriteIfNotBlocked();
@@ -798,7 +798,8 @@ bool QuicConnection::DoWrite() {
   // or the congestion manager to prohibit sending.  If we've sent everything
   // we had queued and we're still not blocked, let the visitor know it can
   // write more.
-  if (CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
+  if (CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
+               NOT_HANDSHAKE)) {
     packet_generator_.StartBatchOperations();
     bool all_bytes_written = visitor_->OnCanWrite();
     packet_generator_.FinishBatchOperations();
@@ -806,7 +807,8 @@ bool QuicConnection::DoWrite() {
     // After the visitor writes, it may have caused the socket to become write
     // blocked or the congestion manager to prohibit sending, so check again.
     if (!write_blocked_ && !all_bytes_written &&
-        CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
+        CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
+                 NOT_HANDSHAKE)) {
       // We're not write blocked, but some stream didn't write out all of its
       // bytes.  Register for 'immediate' resumption so we'll keep writing after
       // other quic connections have had a chance to use the socket.
@@ -984,7 +986,8 @@ void QuicConnection::RetransmitPacket(
 }
 
 bool QuicConnection::CanWrite(Retransmission retransmission,
-                              HasRetransmittableData retransmittable) {
+                              HasRetransmittableData retransmittable,
+                              IsHandshake handshake) {
   // TODO(ianswett): If the packet is a retransmit, the current send alarm may
   // be too long.
   if (write_blocked_ || helper_->IsSendAlarmSet()) {
@@ -993,7 +996,7 @@ bool QuicConnection::CanWrite(Retransmission retransmission,
 
   QuicTime now = clock_->Now();
   QuicTime::Delta delay = congestion_manager_.TimeUntilSend(
-      now, retransmission, retransmittable);
+      now, retransmission, retransmittable, handshake);
   if (delay.IsInfinite()) {
     return false;
   }
@@ -1101,8 +1104,12 @@ bool QuicConnection::WritePacket(EncryptionLevel level,
 
   Retransmission retransmission = IsRetransmission(sequence_number) ?
       IS_RETRANSMISSION : NOT_RETRANSMISSION;
+  IsHandshake handshake = level == ENCRYPTION_NONE ? IS_HANDSHAKE
+                                                   : NOT_HANDSHAKE;
+
   // If we are not forced and we can't write, then simply return false;
-  if (forced == NO_FORCE && !CanWrite(retransmission, retransmittable)) {
+  if (forced == NO_FORCE &&
+      !CanWrite(retransmission, retransmittable, handshake)) {
     return false;
   }
 
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 0152859..8f4f3f1 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -309,7 +309,8 @@ class NET_EXPORT_PRIVATE QuicConnection
   // QuicPacketGenerator::DelegateInterface
   virtual bool CanWrite(
       Retransmission is_retransmission,
-      HasRetransmittableData has_retransmittable_data) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data,
+      IsHandshake handshake) OVERRIDE;
   virtual QuicAckFrame* CreateAckFrame() OVERRIDE;
   virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() OVERRIDE;
   virtual bool OnSerializedPacket(const SerializedPacket& packet) OVERRIDE;
diff --git a/net/quic/quic_connection_helper_test.cc b/net/quic/quic_connection_helper_test.cc
index 21ff95b..a955e4c5 100644
--- a/net/quic/quic_connection_helper_test.cc
+++ b/net/quic/quic_connection_helper_test.cc
@@ -104,7 +104,7 @@ class QuicConnectionHelperTest : public ::testing::Test {
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket_.get());
     send_algorithm_ = new testing::StrictMock<MockSendAlgorithm>();
-    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).
+    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     connection_.reset(new TestConnection(guid_, IPEndPoint(), helper_));
     connection_->set_visitor(&visitor_);
@@ -451,7 +451,7 @@ TEST_F(QuicConnectionHelperTest, SendSchedulerDelayThenSend) {
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
       testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(
-      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
           testing::Return(QuicTime::Delta::FromMicroseconds(1)));
 
   QuicPacket* packet = ConstructRawDataPacket(1);
@@ -462,9 +462,9 @@ TEST_F(QuicConnectionHelperTest, SendSchedulerDelayThenSend) {
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
-  EXPECT_CALL(
-      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
-          testing::Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm_,
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
+      testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
   runner_->RunNextTask();
   EXPECT_EQ(0u, connection_->NumQueuedPackets());
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 39a823e..2161d53a 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -453,8 +453,9 @@ class QuicConnectionTest : public ::testing::Test {
     connection_.SetSendAlgorithm(send_algorithm_);
     // Simplify tests by not sending feedback unless specifically configured.
     SetFeedback(NULL);
-    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillRepeatedly(Return(
-        QuicTime::Delta::Zero()));
+    EXPECT_CALL(
+        *send_algorithm_, TimeUntilSend(_, _, _, _)).WillRepeatedly(Return(
+            QuicTime::Delta::Zero()));
     EXPECT_CALL(*receive_algorithm_,
                 RecordIncomingPacket(_, _, _, _)).Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(AnyNumber());
@@ -841,14 +842,14 @@ TEST_F(QuicConnectionTest, DISABLED_AckReceiptCausesAckSend) {
   ProcessPacket(1);
   // Delay sending, then queue up an ack.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   QuicConnectionPeer::SendAck(&connection_);
 
   // Process an ack with a least unacked of the received ack.
   // This causes an ack to be sent when TimeUntilSend returns 0.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
                   testing::Return(QuicTime::Delta::Zero()));
   // Skip a packet and then record an ack.
   creator_.set_sequence_number(2);
@@ -1160,7 +1161,7 @@ TEST_F(QuicConnectionTest, OnCanWrite) {
       Return(false)));
 
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
                   testing::Return(QuicTime::Delta::Zero()));
 
   // Unblock the connection.
@@ -1767,7 +1768,7 @@ TEST_F(QuicConnectionTest, SendScheduler) {
   // Test that if we send a packet without delay, it is not queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _));
   connection_.SendOrQueuePacket(
@@ -1779,7 +1780,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelay) {
   // Test that if we send a packet with a delay, it ends up queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, _)).Times(0);
   connection_.SendOrQueuePacket(
@@ -1791,7 +1792,7 @@ TEST_F(QuicConnectionTest, SendSchedulerForce) {
   // Test that if we force send a packet, it is not queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, IS_RETRANSMISSION, _)).Times(0);
+              TimeUntilSend(_, IS_RETRANSMISSION, _, _)).Times(0);
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _));
   connection_.SendOrQueuePacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1803,7 +1804,7 @@ TEST_F(QuicConnectionTest, SendSchedulerEAGAIN) {
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   helper_->set_blocked(true);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, 1, _, _)).Times(0);
   connection_.SendOrQueuePacket(
@@ -1815,7 +1816,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenSend) {
   // Test that if we send a packet with a delay, it ends up queued.
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(
        ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1824,7 +1825,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenSend) {
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
                   testing::Return(QuicTime::Delta::Zero()));
   clock_.AdvanceTime(QuicTime::Delta::FromMicroseconds(1));
   helper_->UnregisterSendAlarmIfRegistered();
@@ -1835,7 +1836,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenSend) {
 }
 
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
-  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _))
+  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _))
       .WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, AbandoningPacket(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_,
@@ -1846,7 +1847,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(501));
   // Test that if we send a retransmit with a delay, it ends up queued.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, IS_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, IS_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.OnRetransmissionTimeout();
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
@@ -1854,7 +1855,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, IS_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, IS_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::Zero()));
 
   // Ensure the scheduler is notified this is a retransmit.
@@ -1870,7 +1871,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenRetransmit) {
 TEST_F(QuicConnectionTest, SendSchedulerDelayAndQueue) {
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1886,7 +1887,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayAndQueue) {
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(10)));
   connection_.SendOrQueuePacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1896,7 +1897,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
   // retransmit 3. The far end should stop waiting for it.
   QuicAckFrame frame(0, QuicTime::Zero(), 1);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillRepeatedly(
                   testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_,
               SentPacket(_, _, _, _));
@@ -1910,7 +1911,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndSend) {
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(10)));
   connection_.SendOrQueuePacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1920,7 +1921,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
   // retransmit 3.  The far end should stop waiting for it.
   QuicAckFrame frame(0, QuicTime::Zero(), 1);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   ProcessAckPacket(&frame, false);
 
@@ -1930,7 +1931,7 @@ TEST_F(QuicConnectionTest, SendSchedulerDelayThenAckAndHold) {
 TEST_F(QuicConnectionTest, SendSchedulerDelayThenOnCanWrite) {
   QuicPacket* packet = ConstructDataPacket(1, 0, !kEntropyFlag);
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(10)));
   connection_.SendOrQueuePacket(
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
@@ -1951,7 +1952,7 @@ TEST_F(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
 
   // Queue the first packet.
   EXPECT_CALL(*send_algorithm_,
-              TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+              TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(10)));
   const string payload(payload_length, 'a');
   EXPECT_EQ(0u,
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index d0c6675..9f3a69c 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -170,7 +170,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     receive_algorithm_ = new TestReceiveAlgorithm(NULL);
     EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
         testing::Return(QuicTime::Delta::Zero()));
-    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).
+    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
         WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
     helper_ = new QuicConnectionHelper(runner_.get(), &clock_,
                                        &random_generator_, socket);
diff --git a/net/quic/quic_packet_generator.cc b/net/quic/quic_packet_generator.cc
index 08bad947..34ed0a0 100644
--- a/net/quic/quic_packet_generator.cc
+++ b/net/quic/quic_packet_generator.cc
@@ -75,7 +75,8 @@ QuicConsumedData QuicPacketGenerator::ConsumeData(QuicStreamId id,
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
-  while (delegate_->CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA)) {
+  while (delegate_->CanWrite(NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
+                             NOT_HANDSHAKE)) {
     QuicFrame frame;
     size_t bytes_consumed = packet_creator_->CreateStreamFrame(
         id, data, offset + total_bytes_consumed, fin, &frame);
@@ -120,7 +121,8 @@ bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
   if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
       DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
   }
-  return delegate_->CanWrite(NOT_RETRANSMISSION, retransmittable);
+  return delegate_->CanWrite(NOT_RETRANSMISSION, retransmittable,
+                             NOT_HANDSHAKE);
 }
 
 void QuicPacketGenerator::SendQueuedFrames() {
diff --git a/net/quic/quic_packet_generator.h b/net/quic/quic_packet_generator.h
index ab0dbe2..e8b09e6 100644
--- a/net/quic/quic_packet_generator.h
+++ b/net/quic/quic_packet_generator.h
@@ -63,7 +63,8 @@ class NET_EXPORT_PRIVATE QuicPacketGenerator {
    public:
     virtual ~DelegateInterface() {}
     virtual bool CanWrite(Retransmission retransmission,
-                          HasRetransmittableData retransmittable) = 0;
+                          HasRetransmittableData retransmittable,
+                          IsHandshake handshake) = 0;
     virtual QuicAckFrame* CreateAckFrame() = 0;
     virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() = 0;
     // Takes ownership of |packet.packet| and |packet.retransmittable_frames|.
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index 4511251..45556f1 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -32,32 +32,33 @@ class MockDelegate : public QuicPacketGenerator::DelegateInterface {
   MockDelegate() {}
   virtual ~MockDelegate() {}
 
-  MOCK_METHOD2(CanWrite, bool(Retransmission retransmission,
-                              HasRetransmittableData retransmittable));
+  MOCK_METHOD3(CanWrite, bool(Retransmission retransmission,
+                              HasRetransmittableData retransmittable,
+                              IsHandshake handshake));
 
   MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
   MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
   MOCK_METHOD1(OnSerializedPacket, bool(const SerializedPacket& packet));
 
   void SetCanWriteAnything() {
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _, _))
         .WillRepeatedly(Return(true));
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA, _))
         .WillRepeatedly(Return(true));
   }
 
   void SetCanNotWrite() {
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _, _))
         .WillRepeatedly(Return(false));
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA, _))
         .WillRepeatedly(Return(false));
   }
 
   // Use this when only ack and feedback frames should be allowed to be written.
   void SetCanWriteOnlyNonRetransmittable() {
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _, _))
         .WillRepeatedly(Return(false));
-    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA, _))
         .WillRepeatedly(Return(true));
   }
 
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 93a5333..8b17cd5 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -91,6 +91,11 @@ enum HasRetransmittableData {
   HAS_RETRANSMITTABLE_DATA,
 };
 
+enum IsHandshake {
+  NOT_HANDSHAKE,
+  IS_HANDSHAKE
+};
+
 enum QuicFrameType {
   PADDING_FRAME = 0,
   STREAM_FRAME,
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index d24a2a5..a635a4c 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -334,8 +334,9 @@ class MockSendAlgorithm : public SendAlgorithmInterface {
                                 QuicByteCount, Retransmission));
   MOCK_METHOD2(AbandoningPacket, void(QuicPacketSequenceNumber sequence_number,
                                       QuicByteCount abandoned_bytes));
-  MOCK_METHOD3(TimeUntilSend, QuicTime::Delta(QuicTime now, Retransmission,
-                                              HasRetransmittableData));
+  MOCK_METHOD4(TimeUntilSend, QuicTime::Delta(QuicTime now, Retransmission,
+                                              HasRetransmittableData,
+                                              IsHandshake));
   MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
   MOCK_METHOD0(SmoothedRtt, QuicTime::Delta(void));
   MOCK_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
diff --git a/net/tools/quic/quic_epoll_connection_helper_test.cc b/net/tools/quic/quic_epoll_connection_helper_test.cc
index f765242..ac034fd7 100644
--- a/net/tools/quic/quic_epoll_connection_helper_test.cc
+++ b/net/tools/quic/quic_epoll_connection_helper_test.cc
@@ -85,8 +85,8 @@ class QuicEpollConnectionHelperTest : public ::testing::Test {
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     epoll_server_.set_timeout_in_us(-1);
-    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillRepeatedly(Return(
-        QuicTime::Delta::Zero()));
+    EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _, _)).
+        WillRepeatedly(Return(QuicTime::Delta::Zero()));
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
@@ -184,7 +184,7 @@ TEST_F(QuicEpollConnectionHelperTest, SendSchedulerDelayThenSend) {
       Return(QuicTime::Delta::Zero()));
   QuicPacket* packet = ConstructDataPacket(1, 0);
   EXPECT_CALL(
-      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
+      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).WillOnce(
           testing::Return(QuicTime::Delta::FromMicroseconds(1)));
   connection_.SendOrQueuePacket(ENCRYPTION_NONE, 1, packet, 0,
                                 HAS_RETRANSMITTABLE_DATA);
@@ -193,9 +193,8 @@ TEST_F(QuicEpollConnectionHelperTest, SendSchedulerDelayThenSend) {
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
-  EXPECT_CALL(
-      *send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillRepeatedly(
-          testing::Return(QuicTime::Delta::Zero()));
+  EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, NOT_RETRANSMISSION, _, _)).
+      WillRepeatedly(testing::Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(testing::Return(true));
   epoll_server_.AdvanceByAndCallCallbacks(1);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
author	jar@chromium.org <jar@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2013-08-03 02:06:43 +0000
committer	jar@chromium.org <jar@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>	2013-08-03 02:06:43 +0000
commit	575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1 (patch)
tree	1924938680cb7c579e47fb77f9f6d3c371708325 /net
parent	36e151a64e36f7f5f491e74995f402ef69e9e81c (diff)
download	chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.zip chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.tar.gz chromium_src-575cce6c6b8ce8f5c2dff9dc9ad51a7f302765a1.tar.bz2