Land Recent QUIC Changes

Remove a LOG_IF(DFATAL) for retransmitting packets which were never
given a sent time.

This DCHECK was firing on Chrome when Windows buffered a packet and
before the callback for the packet being sent, Chrome received a server
reject and had to change crypto context and retransmit all unacked
packets.

Merge internal change: 63686840
https://codereview.chromium.org/214413009/


Rename of QUIC flow control member variables to be more explicit (prefix
flow_control) and more descriptive ("max" instead of "initial").

Merge internal change: 63599012
https://codereview.chromium.org/215423003/


Change comment in QuicSessionTest to be more accurate, and add another
expectation to ensure stream is not flow control blocked before sending
any data.

Merge internal change: 63604321

Fixed compilation warnings in quic_sent_packet_manager_test.cc.

https://codereview.chromium.org/214823010/


Added UseWriter changes to QuicTestClient while porting internal
code that handles the client side of unwinding UDP proxied QUIC changes.

Merge internal change: 63542972
https://codereview.chromium.org/214083003/


Change to QUIC's SendAlgorithmInterface to remove IsHandshake from
TimeUntilSend.

Changed QuicSentPacketManager to ensure it always retransmitted crypto
handshake packets before other retransmissions.

Merge internal change: 63540663
https://codereview.chromium.org/214923003/


Removing TransmissionType from QUIC's TimeUntilSend method.

The only real user was was TcpCubicSender for tail loss probe, and TLP
is better fully contained within the SentPacketManager.

Merge internal change: 63501475
https://codereview.chromium.org/214083002/


Removed unnecessary transmission_type from Quic's send algorithm
interface.

The few remaining uses were improper, so there is a minor change in
behavior.

Merge internal change: 63480011
https://codereview.chromium.org/211693004/


Introduce QUIC_VERSION_17: per-stream flow control. Default send window
is 16 KB, and the client/server can specify higher values in their
CHLO/SHLO messages. WINDOW_UPDATE frames are sent when the receiver has
consumed more than half of their receive window (behavior copied from
SPDY), and BLOCKED frames are sent if a write is attempted while flow
control blocked.

Protected behind FLAGS_enable_quic_stream_flow_control.

Merge internal change: 63474251
https://codereview.chromium.org/211743005/


Adding an accessor to quic dispatcher.

Merge internal change: 63470311
https://codereview.chromium.org/208273008/

R=rch@chromium.org

Review URL: https://codereview.chromium.org/215663002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260637 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 226 insertions, 292 deletions

diff --git a/net/quic/congestion_control/channel_estimator.cc b/net/quic/congestion_control/channel_estimator.cc
index a012b66..02e5904 100644
--- a/net/quic/congestion_control/channel_estimator.cc
+++ b/net/quic/congestion_control/channel_estimator.cc
@@ -89,7 +89,7 @@ ChannelEstimateState ChannelEstimator::GetChannelEstimate(
   }
   *estimate = median_bitrate;
   DVLOG(1) << "Channel estimate is:"
-             << median_bitrate.ToKBitsPerSecond() << " Kbit/s";
+           << median_bitrate.ToKBitsPerSecond() << " Kbit/s";
   // If the bitrates in our 25th to 75th percentile window varies more than
   // 25% of the median bitrate we consider the estimate to be uncertain.
   if (bitrate_75th_percentile.Subtract(bitrate_25th_percentile) >
diff --git a/net/quic/congestion_control/fix_rate_sender.cc b/net/quic/congestion_control/fix_rate_sender.cc
index c848280..9d7871e 100644
--- a/net/quic/congestion_control/fix_rate_sender.cc
+++ b/net/quic/congestion_control/fix_rate_sender.cc
@@ -52,6 +52,7 @@ void FixRateSender::OnIncomingQuicCongestionFeedbackFrame(
 void FixRateSender::OnPacketAcked(
     QuicPacketSequenceNumber /*acked_sequence_number*/,
     QuicByteCount bytes_acked) {
+  DCHECK_GE(data_in_flight_, bytes_acked);
   data_in_flight_ -= bytes_acked;
 }
 
@@ -64,13 +65,11 @@ bool FixRateSender::OnPacketSent(
     QuicTime sent_time,
     QuicPacketSequenceNumber /*sequence_number*/,
     QuicByteCount bytes,
-    TransmissionType transmission_type,
     HasRetransmittableData /*has_retransmittable_data*/) {
   fix_rate_leaky_bucket_.Add(sent_time, bytes);
   paced_sender_.OnPacketSent(sent_time, bytes);
-  if (transmission_type == NOT_RETRANSMISSION) {
-    data_in_flight_ += bytes;
-  }
+  data_in_flight_ += bytes;
+
   return true;
 }
 
@@ -78,14 +77,14 @@ void FixRateSender::OnRetransmissionTimeout(bool packets_retransmitted) { }
 
 void FixRateSender::OnPacketAbandoned(
     QuicPacketSequenceNumber /*sequence_number*/,
-    QuicByteCount /*abandoned_bytes*/) {
+    QuicByteCount bytes_abandoned) {
+  DCHECK_GE(data_in_flight_, bytes_abandoned);
+  data_in_flight_ -= bytes_abandoned;
 }
 
 QuicTime::Delta FixRateSender::TimeUntilSend(
     QuicTime now,
-    TransmissionType /* transmission_type */,
-    HasRetransmittableData /*has_retransmittable_data*/,
-    IsHandshake /*handshake*/) {
+    HasRetransmittableData /*has_retransmittable_data*/) {
   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 4a56da0..9dca2e1 100644
--- a/net/quic/congestion_control/fix_rate_sender.h
+++ b/net/quic/congestion_control/fix_rate_sender.h
@@ -37,16 +37,13 @@ class NET_EXPORT_PRIVATE FixRateSender : public SendAlgorithmInterface {
       QuicTime sent_time,
       QuicPacketSequenceNumber sequence_number,
       QuicByteCount bytes,
-      TransmissionType transmission_type,
       HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
-                                 QuicByteCount abandoned_bytes) OVERRIDE;
+                                 QuicByteCount bytes_abandoned) OVERRIDE;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
   virtual void UpdateRtt(QuicTime::Delta rtt_sample) OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
diff --git a/net/quic/congestion_control/fix_rate_test.cc b/net/quic/congestion_control/fix_rate_test.cc
index 16e8a5e..f9c7722 100644
--- a/net/quic/congestion_control/fix_rate_test.cc
+++ b/net/quic/congestion_control/fix_rate_test.cc
@@ -58,27 +58,27 @@ TEST_F(FixRateTest, SenderAPI) {
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback,  clock_.Now());
   EXPECT_EQ(300000, sender_->BandwidthEstimate().ToBytesPerSecond());
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
+
   sender_->OnPacketSent(clock_.Now(), 1, kDefaultMaxPacketSize,
-                        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+                        HAS_RETRANSMITTABLE_DATA);
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   sender_->OnPacketSent(clock_.Now(), 2, kDefaultMaxPacketSize,
-                        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
-  sender_->OnPacketSent(clock_.Now(), 3, 600, NOT_RETRANSMISSION,
+                        HAS_RETRANSMITTABLE_DATA);
+  sender_->OnPacketSent(clock_.Now(), 3, 600,
                         HAS_RETRANSMITTABLE_DATA);
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10),
-      sender_->TimeUntilSend(clock_.Now(),
-          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+      sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
-  EXPECT_EQ(QuicTime::Delta::Infinite(), sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  EXPECT_EQ(QuicTime::Delta::Infinite(),
+            sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8));
   sender_->OnPacketAcked(1, kDefaultMaxPacketSize);
   sender_->OnPacketAcked(2, kDefaultMaxPacketSize);
   sender_->OnPacketAcked(3, 600);
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
 }
 
 TEST_F(FixRateTest, FixRatePacing) {
@@ -93,17 +93,15 @@ TEST_F(FixRateTest, FixRatePacing) {
   QuicPacketSequenceNumber sequence_number = 0;
   for (int i = 0; i < num_packets; i += 2) {
     EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-         NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
-         NOT_HANDSHAKE).IsZero());
+                                       HAS_RETRANSMITTABLE_DATA).IsZero());
     sender_->OnPacketSent(clock_.Now(), sequence_number++, packet_size,
-                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+                          HAS_RETRANSMITTABLE_DATA);
     EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
-        NOT_HANDSHAKE).IsZero());
+                                       HAS_RETRANSMITTABLE_DATA).IsZero());
     sender_->OnPacketSent(clock_.Now(), sequence_number++, packet_size,
-                          NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
-    QuicTime::Delta advance_time = sender_->TimeUntilSend(clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
+                          HAS_RETRANSMITTABLE_DATA);
+    QuicTime::Delta advance_time =
+        sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     clock_.AdvanceTime(advance_time);
     sender_->OnPacketAcked(sequence_number - 1, packet_size);
     sender_->OnPacketAcked(sequence_number - 2, packet_size);
diff --git a/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc b/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
index 39ee5857..801a526 100644
--- a/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
+++ b/net/quic/congestion_control/inter_arrival_bitrate_ramp_up.cc
@@ -78,7 +78,7 @@ void InterArrivalBitrateRampUp::UpdateChannelEstimate(
     halfway_point_ = available_channel_estimate_.Add(
         (channel_estimate_.Subtract(available_channel_estimate_).Scale(0.5f)));
     DVLOG(1) << "UpdateChannelEstimate; first usable value:"
-               << channel_estimate.ToKBitsPerSecond() << " Kbits/s";
+             << channel_estimate.ToKBitsPerSecond() << " Kbits/s";
     return;
   }
   if (current_rate_ < halfway_point_) {
@@ -96,7 +96,7 @@ void InterArrivalBitrateRampUp::UpdateChannelEstimate(
       CalcuateTimeToOriginPoint(channel_estimate_.Subtract(current_rate_));
 
   DVLOG(1) << "UpdateChannelEstimate; time to origin point:"
-             << time_to_origin_point_;
+           << time_to_origin_point_;
 }
 
 QuicBandwidth InterArrivalBitrateRampUp::GetNewBitrate(
@@ -118,9 +118,9 @@ QuicBandwidth InterArrivalBitrateRampUp::GetNewBitrate(
     // We need to update the epoch to reflect this state.
     epoch_ = epoch_.Add(time_from_last_update);
     DVLOG(1) << "Don't increase; our sent bitrate is:"
-               << sent_bitrate.ToKBitsPerSecond() << " Kbits/s"
-               << " current target rate is:"
-               << current_rate_.ToKBitsPerSecond() << " Kbits/s";
+             << sent_bitrate.ToKBitsPerSecond() << " Kbits/s"
+             << " current target rate is:"
+             << current_rate_.ToKBitsPerSecond() << " Kbits/s";
     return current_rate_;
   }
   QuicTime::Delta time_from_epoch = current_time.Subtract(epoch_);
@@ -155,7 +155,7 @@ QuicBandwidth InterArrivalBitrateRampUp::GetNewBitrate(
             CalcuateTimeToOriginPoint(channel_estimate_.Subtract(current_rate));
       }
       DVLOG(1) << "Passed the halfway point; time to origin point:"
-                 << time_to_origin_point_;
+               << time_to_origin_point_;
     }
     current_rate_ = current_rate;
   } else {
diff --git a/net/quic/congestion_control/inter_arrival_overuse_detector.cc b/net/quic/congestion_control/inter_arrival_overuse_detector.cc
index e397c1e..f3f0250 100644
--- a/net/quic/congestion_control/inter_arrival_overuse_detector.cc
+++ b/net/quic/congestion_control/inter_arrival_overuse_detector.cc
@@ -157,7 +157,7 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
       accumulated_deltas_.ToMicroseconds() > kThresholdAccumulatedDeltasUs) {
     if (delta_estimate_ != kBandwidthDraining) {
       DVLOG(1) << "Bandwidth estimate drift: Draining buffer(s) "
-                 << accumulated_deltas_.ToMilliseconds() << " ms";
+               << accumulated_deltas_.ToMilliseconds() << " ms";
       delta_estimate_ = kBandwidthDraining;
     }
     return;
@@ -168,11 +168,11 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
        std::abs(accumulated_deltas_.ToMicroseconds()))) {
     if (delta_estimate_ != kBandwidthSteady) {
       DVLOG(1) << "Bandwidth estimate drift: Steady"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta
-                 << " offset:" << send_receive_offset_.ToMicroseconds()
-                 << " delta:" << estimated_congestion_delay_.ToMicroseconds()
-                 << " drift:" << accumulated_deltas_.ToMicroseconds();
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta
+               << " offset:" << send_receive_offset_.ToMicroseconds()
+               << " delta:" << estimated_congestion_delay_.ToMicroseconds()
+               << " drift:" << accumulated_deltas_.ToMicroseconds();
       delta_estimate_ = kBandwidthSteady;
       // Reset drift counter.
       accumulated_deltas_ = QuicTime::Delta::Zero();
@@ -184,22 +184,22 @@ void InterArrivalOveruseDetector::DetectDrift(int64 sigma_delta) {
     if (delta_estimate_ != kBandwidthOverUsing) {
       ++delta_overuse_counter_;
       DVLOG(1) << "Bandwidth estimate drift: Over using"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta
-                 << " offset:" << send_receive_offset_.ToMicroseconds()
-                 << " delta:" << estimated_congestion_delay_.ToMicroseconds()
-                 << " drift:" << accumulated_deltas_.ToMicroseconds();
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta
+               << " offset:" << send_receive_offset_.ToMicroseconds()
+               << " delta:" << estimated_congestion_delay_.ToMicroseconds()
+               << " drift:" << accumulated_deltas_.ToMicroseconds();
       delta_estimate_ = kBandwidthOverUsing;
     }
   } else {
     if (delta_estimate_ != kBandwidthUnderUsing) {
       --delta_overuse_counter_;
       DVLOG(1) << "Bandwidth estimate drift: Under using"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta
-                 << " offset:" << send_receive_offset_.ToMicroseconds()
-                 << " delta:" << estimated_congestion_delay_.ToMicroseconds()
-                 << " drift:" << accumulated_deltas_.ToMicroseconds();
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta
+               << " offset:" << send_receive_offset_.ToMicroseconds()
+               << " delta:" << estimated_congestion_delay_.ToMicroseconds()
+               << " drift:" << accumulated_deltas_.ToMicroseconds();
       delta_estimate_ = kBandwidthUnderUsing;
     }
     // Adding decay of negative accumulated_deltas_ since it could be caused by
@@ -227,8 +227,8 @@ void InterArrivalOveruseDetector::DetectSlope(int64 sigma_delta) {
   if (sigma_delta > abs(delta_mean_) * kDetectSlopeFactor) {
     if (slope_estimate_ != kBandwidthSteady) {
       DVLOG(1) << "Bandwidth estimate slope: Steady"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta;
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta;
       slope_overuse_counter_ = 0;
       slope_estimate_ = kBandwidthSteady;
     }
@@ -238,16 +238,16 @@ void InterArrivalOveruseDetector::DetectSlope(int64 sigma_delta) {
     if (slope_estimate_ != kBandwidthOverUsing) {
       ++slope_overuse_counter_;
       DVLOG(1) << "Bandwidth estimate slope: Over using"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta;
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta;
       slope_estimate_ = kBandwidthOverUsing;
     }
   } else {
     if (slope_estimate_ != kBandwidthUnderUsing) {
       --slope_overuse_counter_;
       DVLOG(1) << "Bandwidth estimate slope: Under using"
-                 << " mean:" << delta_mean_
-                 << " sigma:" << sigma_delta;
+               << " mean:" << delta_mean_
+               << " sigma:" << sigma_delta;
       slope_estimate_ = kBandwidthUnderUsing;
     }
   }
diff --git a/net/quic/congestion_control/inter_arrival_probe.cc b/net/quic/congestion_control/inter_arrival_probe.cc
index 694c3d7..f9a0362 100644
--- a/net/quic/congestion_control/inter_arrival_probe.cc
+++ b/net/quic/congestion_control/inter_arrival_probe.cc
@@ -121,8 +121,8 @@ void InterArrivalProbe::OnIncomingFeedback(
   estimate_available_ = true;
   available_channel_estimator_.reset(NULL);
   DVLOG(1) << "Probe estimate:"
-             << available_channel_estimate_.ToKBitsPerSecond()
-             << " Kbits/s";
+           << available_channel_estimate_.ToKBitsPerSecond()
+           << " Kbits/s";
 }
 
 }  // namespace net
diff --git a/net/quic/congestion_control/inter_arrival_sender.cc b/net/quic/congestion_control/inter_arrival_sender.cc
index 1b46455..864db7d 100644
--- a/net/quic/congestion_control/inter_arrival_sender.cc
+++ b/net/quic/congestion_control/inter_arrival_sender.cc
@@ -111,7 +111,7 @@ void InterArrivalSender::OnIncomingQuicCongestionFeedbackFrame(
     if (sent_it == packet_history_map_.end()) {
       // Too old data; ignore and move forward.
       DVLOG(1) << "Too old feedback move forward, sequence_number:"
-                 << sequence_number;
+               << sequence_number;
       continue;
     }
     QuicTime time_received = received_it->second;
@@ -187,11 +187,11 @@ bool InterArrivalSender::ProbingPhase(QuicTime feedback_receive_time) {
   current_bandwidth_ = new_rate;
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time, new_rate);
   DVLOG(1) << "Probe result; new rate:"
-             << new_rate.ToKBitsPerSecond() << " Kbits/s "
-             << " available estimate:"
-             << available_channel_estimate.ToKBitsPerSecond() << " Kbits/s "
-             << " channel estimate:"
-             << channel_estimate.ToKBitsPerSecond() << " Kbits/s ";
+           << new_rate.ToKBitsPerSecond() << " Kbits/s "
+           << " available estimate:"
+           << available_channel_estimate.ToKBitsPerSecond() << " Kbits/s "
+           << " channel estimate:"
+           << channel_estimate.ToKBitsPerSecond() << " Kbits/s ";
   return false;
 }
 
@@ -221,7 +221,6 @@ bool InterArrivalSender::OnPacketSent(
     QuicTime sent_time,
     QuicPacketSequenceNumber sequence_number,
     QuicByteCount bytes,
-    TransmissionType /*transmission_type*/,
     HasRetransmittableData /*has_retransmittable_data*/) {
   if (probing_) {
     probe_->OnPacketSent(bytes);
@@ -252,9 +251,7 @@ void InterArrivalSender::OnPacketAbandoned(
 
 QuicTime::Delta InterArrivalSender::TimeUntilSend(
     QuicTime now,
-    TransmissionType /*transmission_type*/,
-    HasRetransmittableData has_retransmittable_data,
-    IsHandshake /*handshake*/) {
+    HasRetransmittableData has_retransmittable_data) {
   // TODO(pwestin): implement outer_congestion_window_ logic.
   QuicTime::Delta outer_window = QuicTime::Delta::Zero();
 
@@ -337,8 +334,8 @@ void InterArrivalSender::EstimateNewBandwidth(QuicTime feedback_receive_time,
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time,
                                          current_bandwidth_);
   DVLOG(1) << "New bandwidth estimate in steady state:"
-             << current_bandwidth_.ToKBitsPerSecond()
-             << " Kbits/s";
+           << current_bandwidth_.ToKBitsPerSecond()
+           << " Kbits/s";
 }
 
 // Did we drain the network buffers in our expected pace?
@@ -385,15 +382,15 @@ void InterArrivalSender::EstimateNewBandwidthAfterDraining(
                          current_bandwidth_.Add(draining_rate).Scale(
                              1.0f - kMinBitrateReduction));
       DVLOG(1) << "Draining calculation; current rate:"
-                 << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s "
-                 << "draining rate:"
-                 << draining_rate.ToKBitsPerSecond() << " Kbits/s "
-                 << "new estimate:"
-                 << new_estimate.ToKBitsPerSecond() << " Kbits/s "
-                 << " buffer reduction:"
-                 << buffer_reduction.ToMicroseconds() << " us "
-                 << " elapsed time:"
-                 << elapsed_time.ToMicroseconds()  << " us ";
+               << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s "
+               << "draining rate:"
+               << draining_rate.ToKBitsPerSecond() << " Kbits/s "
+               << "new estimate:"
+               << new_estimate.ToKBitsPerSecond() << " Kbits/s "
+               << " buffer reduction:"
+               << buffer_reduction.ToMicroseconds() << " us "
+               << " elapsed time:"
+               << elapsed_time.ToMicroseconds()  << " us ";
     }
   }
   if (new_estimate == current_bandwidth_) {
@@ -421,7 +418,7 @@ void InterArrivalSender::EstimateNewBandwidthAfterDraining(
   paced_sender_->UpdateBandwidthEstimate(feedback_receive_time, new_estimate);
   current_bandwidth_ = new_estimate;
   DVLOG(1) << "New bandwidth estimate after draining:"
-             << new_estimate.ToKBitsPerSecond() << " Kbits/s";
+           << new_estimate.ToKBitsPerSecond() << " Kbits/s";
 }
 
 void InterArrivalSender::EstimateBandwidthAfterDelayEvent(
@@ -464,7 +461,7 @@ void InterArrivalSender::EstimateBandwidthAfterLossEvent(
   ResetCurrentBandwidth(feedback_receive_time,
                         current_bandwidth_.Scale(kPacketLossBitrateReduction));
   DVLOG(1) << "New bandwidth estimate after loss event:"
-             << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s";
+           << current_bandwidth_.ToKBitsPerSecond() << " Kbits/s";
 }
 
 void InterArrivalSender::ResetCurrentBandwidth(QuicTime feedback_receive_time,
diff --git a/net/quic/congestion_control/inter_arrival_sender.h b/net/quic/congestion_control/inter_arrival_sender.h
index 2de370d..e0812f1 100644
--- a/net/quic/congestion_control/inter_arrival_sender.h
+++ b/net/quic/congestion_control/inter_arrival_sender.h
@@ -40,16 +40,13 @@ class NET_EXPORT_PRIVATE InterArrivalSender : public SendAlgorithmInterface {
       QuicTime sent_time,
       QuicPacketSequenceNumber sequence_number,
       QuicByteCount bytes,
-      TransmissionType transmission_type,
       HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
                                  QuicByteCount abandoned_bytes) OVERRIDE;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
   virtual void UpdateRtt(QuicTime::Delta rtt_sample) OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
diff --git a/net/quic/congestion_control/inter_arrival_sender_test.cc b/net/quic/congestion_control/inter_arrival_sender_test.cc
index 048cbb0..c3335fc 100644
--- a/net/quic/congestion_control/inter_arrival_sender_test.cc
+++ b/net/quic/congestion_control/inter_arrival_sender_test.cc
@@ -36,14 +36,14 @@ class InterArrivalSenderTest : public ::testing::Test {
 
   void SendAvailableCongestionWindow() {
     while (sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero()) {
+        HAS_RETRANSMITTABLE_DATA).IsZero()) {
       QuicByteCount bytes_in_packet = kDefaultMaxPacketSize;
       sender_.OnPacketSent(send_clock_.Now(), sequence_number_, bytes_in_packet,
-                           NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+                           HAS_RETRANSMITTABLE_DATA);
       sequence_number_++;
     }
     EXPECT_FALSE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                       HAS_RETRANSMITTABLE_DATA).IsZero());
   }
 
   void AckNPackets(int n) {
@@ -114,28 +114,28 @@ 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, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).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, NOT_HANDSHAKE));
+                                                  HAS_RETRANSMITTABLE_DATA));
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+      HAS_RETRANSMITTABLE_DATA).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+      HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -147,11 +147,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -162,11 +162,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -177,11 +177,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -193,11 +193,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -209,11 +209,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -224,11 +224,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -239,11 +239,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -259,11 +259,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -275,11 +275,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -292,28 +292,28 @@ 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, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).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, NOT_HANDSHAKE));
+                                                  HAS_RETRANSMITTABLE_DATA));
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+                                    HAS_RETRANSMITTABLE_DATA).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
-  send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+  send_clock_.AdvanceTime(
+      sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -325,11 +325,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -338,10 +338,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, NOT_HANDSHAKE));
+  send_clock_.AdvanceTime(
+      sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
   AckNPackets(2);
 
   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
@@ -357,9 +357,9 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedBySlowDrain) {
   while (send_clock_.Now() < receive_clock_.Now()) {
     SendAvailableCongestionWindow();
     send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+                                                  HAS_RETRANSMITTABLE_DATA));
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, one_ms_);
   }
@@ -372,11 +372,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -389,28 +389,29 @@ 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, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).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, NOT_HANDSHAKE));
-    EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                                  HAS_RETRANSMITTABLE_DATA));
+    EXPECT_TRUE(
+        sender_.TimeUntilSend(send_clock_.Now(),
+                              HAS_RETRANSMITTABLE_DATA).IsZero());
   }
   SendAvailableCongestionWindow();
 
   // We have now sent our probe.
-  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(), NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsInfinite());
+  EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
+                                    HAS_RETRANSMITTABLE_DATA).IsInfinite());
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, one_ms_, nine_ms_);
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+                                                HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
 
   // We should now have our probe rate.
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(41);
@@ -422,11 +423,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     AckNPackets(2);
     SendFeedbackMessageNPackets(2, one_ms_, time_until_send.Subtract(one_ms_));
   }
@@ -436,9 +437,9 @@ TEST_F(InterArrivalSenderTest, DelaySpikeFollowedByImmediateDrain) {
 
   SendAvailableCongestionWindow();
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+                                                HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
   AckNPackets(2);
 
   int64 rate_at_introduced_delay_spike = 0.875f * probe_rate;
@@ -469,15 +470,14 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToDelay) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
-
+                                    HAS_RETRANSMITTABLE_DATA).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, NOT_HANDSHAKE));
+                                                  HAS_RETRANSMITTABLE_DATA));
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
   }
   SendAvailableCongestionWindow();
 
@@ -487,9 +487,9 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToDelay) {
   // our minimum bitrate.
   SendFeedbackMessageNPackets(10, one_s_, one_s_);
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+                                                HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
   EXPECT_EQ(expected_min_bitrate, sender_.BandwidthEstimate());
 }
 
@@ -499,24 +499,24 @@ TEST_F(InterArrivalSenderTest, MinBitrateDueToLoss) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).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, NOT_HANDSHAKE));
+                                                  HAS_RETRANSMITTABLE_DATA));
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
   }
   SendAvailableCongestionWindow();
 
   AckNPackets(10);
   SendFeedbackMessageNPackets(10, nine_ms_, nine_ms_);
   send_clock_.AdvanceTime(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
+                                                HAS_RETRANSMITTABLE_DATA));
   EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                    HAS_RETRANSMITTABLE_DATA).IsZero());
 
   QuicTime::Delta acc_arrival_time = QuicTime::Delta::FromMilliseconds(81);
   int64 probe_rate = kDefaultMaxPacketSize * 9 * kNumMicrosPerSecond /
@@ -526,11 +526,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     sender_.OnPacketLost(acked_sequence_number_ - 1, send_clock_.Now());
     sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
@@ -541,11 +541,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, NOT_HANDSHAKE);
+    QuicTime::Delta time_until_send =
+        sender_.TimeUntilSend(send_clock_.Now(), HAS_RETRANSMITTABLE_DATA);
     send_clock_.AdvanceTime(time_until_send);
     EXPECT_TRUE(sender_.TimeUntilSend(send_clock_.Now(),
-        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
     sender_.OnPacketLost(acked_sequence_number_ - 1, send_clock_.Now());
     sender_.OnPacketAcked(acked_sequence_number_, kDefaultMaxPacketSize);
     acked_sequence_number_ += 2;  // Create a loss by not acking both packets.
diff --git a/net/quic/congestion_control/pacing_sender.cc b/net/quic/congestion_control/pacing_sender.cc
index 3a16667..ffbb6fe 100644
--- a/net/quic/congestion_control/pacing_sender.cc
+++ b/net/quic/congestion_control/pacing_sender.cc
@@ -43,7 +43,6 @@ bool PacingSender::OnPacketSent(
     QuicTime sent_time,
     QuicPacketSequenceNumber sequence_number,
     QuicByteCount bytes,
-    TransmissionType transmission_type,
     HasRetransmittableData has_retransmittable_data) {
   // Only pace data packets once we have an updated RTT.
   if (has_retransmittable_data == HAS_RETRANSMITTABLE_DATA && updated_rtt_) {
@@ -57,7 +56,7 @@ bool PacingSender::OnPacketSent(
     next_packet_send_time_ = next_packet_send_time_.Add(delay);
   }
   return sender_->OnPacketSent(sent_time, sequence_number, bytes,
-                               transmission_type, has_retransmittable_data);
+                               has_retransmittable_data);
 }
 
 void PacingSender::OnRetransmissionTimeout(bool packets_retransmitted) {
@@ -71,12 +70,9 @@ void PacingSender::OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
 
 QuicTime::Delta PacingSender::TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) {
+      HasRetransmittableData has_retransmittable_data) {
   QuicTime::Delta time_until_send =
-      sender_->TimeUntilSend(now, transmission_type,
-                             has_retransmittable_data, handshake);
+      sender_->TimeUntilSend(now, has_retransmittable_data);
   if (!updated_rtt_) {
     // Don't pace if we don't have an updated RTT estimate.
     return time_until_send;
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index 9fa4eb6..498ad80 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -41,16 +41,13 @@ class NET_EXPORT_PRIVATE PacingSender : public SendAlgorithmInterface {
   virtual bool OnPacketSent(QuicTime sent_time,
                             QuicPacketSequenceNumber sequence_number,
                             QuicByteCount bytes,
-                            TransmissionType transmission_type,
                             HasRetransmittableData is_retransmittable) OVERRIDE;
   virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
                                  QuicByteCount abandoned_bytes) OVERRIDE;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
   virtual void UpdateRtt(QuicTime::Delta rtt_sample) OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index 0874273..853e9df 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -36,22 +36,19 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             HAS_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet can be sent immediately.
     EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            HAS_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE));
+              pacing_sender_->TimeUntilSend(clock_.Now(),
+                                            HAS_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
                 OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
-                             NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
+                             HAS_RETRANSMITTABLE_DATA));
     pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
-                                 kMaxPacketSize, NOT_RETRANSMISSION,
+                                 kMaxPacketSize,
                                  HAS_RETRANSMITTABLE_DATA);
   }
 
@@ -59,22 +56,19 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the ack to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             NO_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             NO_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the ACK can be sent immediately.
     EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            NO_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE));
+              pacing_sender_->TimeUntilSend(clock_.Now(),
+                                            NO_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
                 OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
-                             NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
+                             NO_RETRANSMITTABLE_DATA));
     pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
-                                 kMaxPacketSize, NOT_RETRANSMISSION,
+                                 kMaxPacketSize,
                                  NO_RETRANSMITTABLE_DATA);
   }
 
@@ -82,15 +76,12 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             HAS_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet is delayed.
     EXPECT_EQ(delay.ToMicroseconds(),
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            HAS_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE).ToMicroseconds());
+              pacing_sender_->TimeUntilSend(
+                  clock_.Now(), HAS_RETRANSMITTABLE_DATA).ToMicroseconds());
   }
 
   const QuicTime::Delta zero_time_;
@@ -103,26 +94,20 @@ class PacingSenderTest : public ::testing::Test {
 
 TEST_F(PacingSenderTest, NoSend) {
   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           NOT_RETRANSMISSION,
-                                           HAS_RETRANSMITTABLE_DATA,
-                                           NOT_HANDSHAKE))
+                                           HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(infinite_time_));
   EXPECT_EQ(infinite_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                          HAS_RETRANSMITTABLE_DATA,
-                                          NOT_HANDSHAKE));
+            pacing_sender_->TimeUntilSend(clock_.Now(),
+                                          HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, SendNow) {
   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           NOT_RETRANSMISSION,
-                                           HAS_RETRANSMITTABLE_DATA,
-                                           NOT_HANDSHAKE))
+                                           HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(zero_time_));
   EXPECT_EQ(zero_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                          HAS_RETRANSMITTABLE_DATA,
-                                          NOT_HANDSHAKE));
+            pacing_sender_->TimeUntilSend(clock_.Now(),
+                                          HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, VariousSending) {
diff --git a/net/quic/congestion_control/send_algorithm_interface.h b/net/quic/congestion_control/send_algorithm_interface.h
index afd5258..d239f66 100644
--- a/net/quic/congestion_control/send_algorithm_interface.h
+++ b/net/quic/congestion_control/send_algorithm_interface.h
@@ -56,7 +56,6 @@ class NET_EXPORT_PRIVATE SendAlgorithmInterface {
   virtual bool OnPacketSent(QuicTime sent_time,
                             QuicPacketSequenceNumber sequence_number,
                             QuicByteCount bytes,
-                            TransmissionType transmission_type,
                             HasRetransmittableData is_retransmittable) = 0;
 
   // Called when the retransmission timeout fires.  Neither OnPacketAbandoned
@@ -70,9 +69,7 @@ class NET_EXPORT_PRIVATE SendAlgorithmInterface {
   // Calculate the time until we can send the next packet.
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) = 0;
+      HasRetransmittableData has_retransmittable_data) = 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 89c240b..835be60 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender.cc
@@ -132,7 +132,6 @@ void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
 bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
                                   QuicPacketSequenceNumber sequence_number,
                                   QuicByteCount bytes,
-                                  TransmissionType transmission_type,
                                   HasRetransmittableData is_retransmittable) {
   // Only update bytes_in_flight_ for data packets.
   if (is_retransmittable != HAS_RETRANSMITTABLE_DATA) {
@@ -146,7 +145,7 @@ bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
     // DCHECK_LT(largest_sent_sequence_number_, sequence_number);
     largest_sent_sequence_number_ = sequence_number;
   }
-  if (transmission_type == NOT_RETRANSMISSION && update_end_sequence_number_) {
+  if (update_end_sequence_number_) {
     end_sequence_number_ = sequence_number;
     if (AvailableSendWindow() == 0) {
       update_end_sequence_number_ = false;
@@ -164,17 +163,9 @@ void TcpCubicSender::OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
 
 QuicTime::Delta TcpCubicSender::TimeUntilSend(
     QuicTime /* now */,
-    TransmissionType transmission_type,
-    HasRetransmittableData has_retransmittable_data,
-    IsHandshake handshake) {
-  if (transmission_type == TLP_RETRANSMISSION ||
-      transmission_type == HANDSHAKE_RETRANSMISSION ||
-      has_retransmittable_data == NO_RETRANSMITTABLE_DATA ||
-      handshake == IS_HANDSHAKE) {
+    HasRetransmittableData has_retransmittable_data) {
+  if (has_retransmittable_data == NO_RETRANSMITTABLE_DATA) {
     // For TCP we can always send 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.
     // We also allow tail loss probes to be sent immediately, in keeping with
     // tail loss probe (draft-dukkipati-tcpm-tcp-loss-probe-01).
     return QuicTime::Delta::Zero();
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index 89e9bd6..93204d4 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -52,16 +52,13 @@ class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
   virtual bool OnPacketSent(QuicTime sent_time,
                             QuicPacketSequenceNumber sequence_number,
                             QuicByteCount bytes,
-                            TransmissionType transmission_type,
                             HasRetransmittableData is_retransmittable) OVERRIDE;
   virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
                                  QuicByteCount abandoned_bytes) OVERRIDE;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
-      TransmissionType transmission_type,
-      HasRetransmittableData has_retransmittable_data,
-      IsHandshake handshake) OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) OVERRIDE;
   virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
   virtual void UpdateRtt(QuicTime::Delta rtt_sample) OVERRIDE;
   virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 1df3b36..c4cbfaf 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -58,15 +58,13 @@ class TcpCubicSenderTest : public ::testing::Test {
     // Send as long as TimeUntilSend returns Zero.
     int packets_sent = 0;
     bool can_send = sender_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION,
-        HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero();
+        clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero();
     while (can_send) {
       sender_->OnPacketSent(clock_.Now(), sequence_number_++, kDefaultTCPMSS,
-                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+                            HAS_RETRANSMITTABLE_DATA);
       ++packets_sent;
       can_send = sender_->TimeUntilSend(
-          clock_.Now(), NOT_RETRANSMISSION,
-          HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero();
+          clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero();
     }
     return packets_sent;
   }
@@ -109,41 +107,26 @@ TEST_F(TcpCubicSenderTest, SimpleSender) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
+
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // And that window is un-affected.
   EXPECT_EQ(kDefaultWindowTCP, sender_->AvailableSendWindow());
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 
-  // A retransmit should always return 0.
-  for (int i = FIRST_TRANSMISSION_TYPE; i <= LAST_TRANSMISSION_TYPE; ++i) {
-    TransmissionType type = static_cast<TransmissionType>(i);
-    EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-                                       type,
-                                       HAS_RETRANSMITTABLE_DATA,
-                                       NOT_HANDSHAKE).IsZero())
-        << QuicUtils::TransmissionTypeToString(type);
-  }
+  // There is available window, so we should be able to send.
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
 
-  // Fill the send window with data, then verify that we can still
-  // send handshake and TLP packets.
+  // Fill the send window with data, then verify that we can't send.
   SendAvailableSendWindow();
-  for (int i = FIRST_TRANSMISSION_TYPE; i <= LAST_TRANSMISSION_TYPE; ++i) {
-    TransmissionType type = static_cast<TransmissionType>(i);
-    bool expect_can_send = (type == HANDSHAKE_RETRANSMISSION ||
-                            type == TLP_RETRANSMISSION);
-    EXPECT_EQ(expect_can_send,
-              sender_->TimeUntilSend(clock_.Now(),
-                                     type,
-                                     HAS_RETRANSMITTABLE_DATA,
-                                     NOT_HANDSHAKE).IsZero())
-        << QuicUtils::TransmissionTypeToString(type);
-  }
+  EXPECT_FALSE(sender_->TimeUntilSend(clock_.Now(),
+                                      HAS_RETRANSMITTABLE_DATA).IsZero());
 }
 
 TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
@@ -151,13 +134,13 @@ TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
@@ -179,13 +162,13 @@ TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
@@ -217,13 +200,13 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   const int kNumberOfAcks = 10;
   for (int i = 0; i < kNumberOfAcks; ++i) {
@@ -240,8 +223,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
   ++acked_sequence_number_;
 
   // Make sure that we can send right now due to limited transmit.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
 
   // We should now have fallen out of slow start.
   // We expect window to be cut in half by Reno.
@@ -280,7 +263,7 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
@@ -305,8 +288,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // Send 1 packet to simulate limited transmit.
-  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-      HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+  EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
+                                     HAS_RETRANSMITTABLE_DATA).IsZero());
   EXPECT_EQ(1, SendAvailableSendWindow());
 
   // Testing TCP proportional rate reduction.
@@ -319,8 +302,7 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
   for (size_t i = 0; i < remaining_packets_in_recovery - 1; i += 2) {
     AckNPackets(2);
     EXPECT_TRUE(sender_->TimeUntilSend(
-        clock_.Now(), NOT_RETRANSMISSION,
-        HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+        clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
     EXPECT_EQ(0u, sender_->AvailableSendWindow());
     EXPECT_EQ(1, SendAvailableSendWindow());
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
@@ -350,7 +332,7 @@ TEST_F(TcpCubicSenderTest, SlowStartBurstPacketLossPRR) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
@@ -466,13 +448,13 @@ TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
@@ -493,13 +475,14 @@ TEST_F(TcpCubicSenderTest, TcpRenoMaxCongestionWindow) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
+
 
   SendAvailableSendWindow();
   AckNPackets(2);
@@ -528,13 +511,13 @@ TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   SendAvailableSendWindow();
   AckNPackets(2);
@@ -575,13 +558,13 @@ TEST_F(TcpCubicSenderTest, SendWindowNotAffectedByAcks) {
   // window doesn't change.
   QuicByteCount bytes_in_packet = min(kDefaultTCPMSS, send_window);
   sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
-                        NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA);
+                        NO_RETRANSMITTABLE_DATA);
   EXPECT_EQ(send_window, sender_->AvailableSendWindow());
 
   // Send a data packet with retransmittable data, and ensure that the
   // congestion window has shrunk.
   sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
-                        NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+                        HAS_RETRANSMITTABLE_DATA);
   EXPECT_GT(send_window, sender_->AvailableSendWindow());
 }
 
@@ -601,7 +584,7 @@ TEST_F(TcpCubicSenderTest, CongestionAvoidanceAtEndOfRecovery) {
   QuicCongestionFeedbackFrame feedback;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
-      NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
+      HAS_RETRANSMITTABLE_DATA).IsZero());
   // Get default QuicCongestionFeedbackFrame from receiver.
   ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
   sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());