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

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 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/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 44 matching lines @@
   const vector<CryptoHandshakeMessage>& messages() const {
     return messages_;
   }
 
  private:
   bool error_;
   vector<CryptoHandshakeMessage> messages_;
 };
 
 // MovePackets parses crypto handshake messages from packet number
-// |*inout_packet_index| through to the last packet and has |dest_stream|
-// process them. |*inout_packet_index| is updated with an index one greater
-// than the last packet processed.
+// |*inout_packet_index| through to the last packet (or until a packet fails to
+// decrypt) and has |dest_stream| process them. |*inout_packet_index| is updated
+// with an index one greater than the last packet processed.
 void MovePackets(PacketSavingConnection* source_conn,
                  size_t *inout_packet_index,
                  QuicCryptoStream* dest_stream,
                  PacketSavingConnection* dest_conn) {
   SimpleQuicFramer framer(source_conn->supported_versions());
   CryptoFramer crypto_framer;
   CryptoFramerVisitor crypto_visitor;
 
   // In order to properly test the code we need to perform encryption and
   // decryption so that the crypters latch when expected. The crypters are in
   // |dest_conn|, but we don't want to try and use them there. Instead we swap
   // them into |framer|, perform the decryption with them, and then swap them
   // back.
   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 
   crypto_framer.set_visitor(&crypto_visitor);
 
   size_t index = *inout_packet_index;
   for (; index < source_conn->encrypted_packets_.size(); index++) {
-    ASSERT_TRUE(framer.ProcessPacket(*source_conn->encrypted_packets_[index]));
+    if (!framer.ProcessPacket(*source_conn->encrypted_packets_[index])) {
+      // The framer will be unable to decrypt forward-secure packets sent after
+      // the handshake is complete. Don't treat them as handshake packets.
+      break;
+    }
+
     for (vector<QuicStreamFrame>::const_iterator
          i =  framer.stream_frames().begin();
          i != framer.stream_frames().end(); ++i) {
       scoped_ptr<string> frame_data(i->GetDataAsString());
       ASSERT_TRUE(crypto_framer.ProcessInput(*frame_data));
       ASSERT_FALSE(crypto_visitor.error());
     }
   }
   *inout_packet_index = index;
 
@@ skipping 526 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net