Along with sending the SCUP message, this CL includes small fixes which

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_sent_packet_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 69 matching lines @@
                                                      congestion_control_type,
                                                      stats)),
       loss_algorithm_(LossDetectionInterface::Create(loss_type)),
       largest_observed_(0),
       first_rto_transmission_(0),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
       consecutive_crypto_retransmission_count_(0),
       pending_tlp_transmission_(false),
       max_tail_loss_probes_(kDefaultMaxTailLossProbes),
-      using_pacing_(false) {
+      using_pacing_(false),
+      handshake_confirmed_(false) {
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {
 }
 
 void QuicSentPacketManager::SetFromConfig(const QuicConfig& config) {
   if (config.HasReceivedInitialRoundTripTimeUs() &&
       config.ReceivedInitialRoundTripTimeUs() > 0) {
     rtt_stats_.set_initial_rtt_us(min(kMaxInitialRoundTripTimeUs,
                                       config.ReceivedInitialRoundTripTimeUs()));
@@ skipping 498 matching lines @@
     return false;
   }
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     QuicPacketSequenceNumber sequence_number = it->first;
     const RetransmittableFrames* frames = it->second.retransmittable_frames;
     // Only retransmit frames which are in flight, and therefore have been sent.
     if (!it->second.in_flight || frames == NULL) {
       continue;
     }
-    DCHECK_NE(IS_HANDSHAKE, frames->HasCryptoHandshake());
+    if (!handshake_confirmed_) {
+      DCHECK_NE(IS_HANDSHAKE, frames->HasCryptoHandshake());
+    }
     MarkForRetransmission(sequence_number, TLP_RETRANSMISSION);
     return true;
   }
   DLOG(FATAL)
     << "No retransmittable packets, so RetransmitOldestPacket failed.";
   return false;
 }
 
 void QuicSentPacketManager::RetransmitAllPackets() {
   DVLOG(1) << "RetransmitAllPackets() called with "
@@ skipping 25 matching lines @@
   }
 
   if (network_change_visitor_ != NULL) {
     network_change_visitor_->OnCongestionWindowChange(GetCongestionWindow());
   }
 }
 
 QuicSentPacketManager::RetransmissionTimeoutMode
     QuicSentPacketManager::GetRetransmissionMode() const {
   DCHECK(unacked_packets_.HasInFlightPackets());
-  if (unacked_packets_.HasPendingCryptoPackets()) {
+  if (!handshake_confirmed_ && unacked_packets_.HasPendingCryptoPackets()) {
     return HANDSHAKE_MODE;
   }
   if (loss_algorithm_->GetLossTimeout() != QuicTime::Zero()) {
     return LOSS_MODE;
   }
   if (consecutive_tlp_count_ < max_tail_loss_probes_) {
     if (unacked_packets_.HasUnackedRetransmittableFrames()) {
       return TLP_MODE;
     }
   }
@@ skipping 196 matching lines @@
 
   // Set up a pacing sender with a 5 millisecond alarm granularity.
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMilliseconds(5),
                        kInitialUnpacedBurst));
 }
 
 }  // namespace net