diff --git a/net/net.gypi b/net/net.gypi
index 9d97fd1..070cf4f 100644
--- a/net/net.gypi
+++ b/net/net.gypi
@@ -345,6 +345,8 @@
       'quic/quic_frame_list.h',
       'quic/quic_framer.cc',
       'quic/quic_framer.h',
+      'quic/quic_multipath_transmissions_map.cc',
+      'quic/quic_multipath_transmissions_map.h',
       'quic/quic_packet_creator.cc',
       'quic/quic_packet_creator.h',
       'quic/quic_packet_generator.cc',
@@ -1542,6 +1544,7 @@
       'quic/quic_headers_stream_test.cc',
       'quic/quic_http_stream_test.cc',
       'quic/quic_http_utils_test.cc',
+      'quic/quic_multipath_transmissions_map_test.cc',
       'quic/quic_network_transaction_unittest.cc',
       'quic/quic_packet_creator_test.cc',
       'quic/quic_packet_generator_test.cc',
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index f9c3f7b..bc59aec4 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -52,6 +52,7 @@
                     QuicByteCount bytes,
                     HasRetransmittableData is_retransmittable) override;
   void OnRetransmissionTimeout(bool packets_retransmitted) override;
+  void OnConnectionMigration() override {}
   QuicTime::Delta TimeUntilSend(
       QuicTime now,
       QuicByteCount bytes_in_flight,
diff --git a/net/quic/congestion_control/rtt_stats.h b/net/quic/congestion_control/rtt_stats.h
index a14cfcb..df1df773 100644
--- a/net/quic/congestion_control/rtt_stats.h
+++ b/net/quic/congestion_control/rtt_stats.h
@@ -38,6 +38,9 @@
   // |num_samples| UpdateRtt calls.
   void SampleNewRecentMinRtt(uint32 num_samples);
 
+  // Called when connection migrates and rtt measurement needs to be reset.
+  void OnConnectionMigration() {}
+
   // Returns the EWMA smoothed RTT for the connection.
   // May return Zero if no valid updates have occurred.
   QuicTime::Delta smoothed_rtt() const {
diff --git a/net/quic/congestion_control/send_algorithm_interface.h b/net/quic/congestion_control/send_algorithm_interface.h
index f59def5f..4f090f91 100644
--- a/net/quic/congestion_control/send_algorithm_interface.h
+++ b/net/quic/congestion_control/send_algorithm_interface.h
@@ -75,6 +75,9 @@
   // nor OnPacketLost will be called for these packets.
   virtual void OnRetransmissionTimeout(bool packets_retransmitted) = 0;
 
+  // Called when connection migrates and cwnd needs to be reset.
+  virtual void OnConnectionMigration() = 0;
+
   // Calculate the time until we can send the next packet.
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
diff --git a/net/quic/congestion_control/tcp_cubic_bytes_sender.h b/net/quic/congestion_control/tcp_cubic_bytes_sender.h
index 9040fb6..e340fcc 100644
--- a/net/quic/congestion_control/tcp_cubic_bytes_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_bytes_sender.h
@@ -54,6 +54,7 @@
                     QuicByteCount bytes,
                     HasRetransmittableData is_retransmittable) override;
   void OnRetransmissionTimeout(bool packets_retransmitted) override;
+  void OnConnectionMigration() override {}
   QuicTime::Delta TimeUntilSend(
       QuicTime now,
       QuicByteCount bytes_in_flight,
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index e4eb9081..723ab07 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -56,6 +56,7 @@
                     QuicByteCount bytes,
                     HasRetransmittableData is_retransmittable) override;
   void OnRetransmissionTimeout(bool packets_retransmitted) override;
+  void OnConnectionMigration() override {}
   QuicTime::Delta TimeUntilSend(
       QuicTime now,
       QuicByteCount bytes_in_flight,
diff --git a/net/quic/crypto/crypto_handshake.cc b/net/quic/crypto/crypto_handshake.cc
index 7676c8cc..26e69bc 100644
--- a/net/quic/crypto/crypto_handshake.cc
+++ b/net/quic/crypto/crypto_handshake.cc
@@ -14,6 +14,7 @@
 QuicCryptoNegotiatedParameters::QuicCryptoNegotiatedParameters()
     : key_exchange(0),
       aead(0),
+      token_binding_key_param(0),
       x509_ecdsa_supported(false),
       x509_supported(false),
       sct_supported_by_client(false) {}
diff --git a/net/quic/crypto/crypto_handshake.h b/net/quic/crypto/crypto_handshake.h
index ef4fe22..2f432a40 100644
--- a/net/quic/crypto/crypto_handshake.h
+++ b/net/quic/crypto/crypto_handshake.h
@@ -129,6 +129,7 @@
   // bytes of x coordinate, followed by 32 bytes of y coordinate. Both values
   // are big-endian and the pair is a P-256 public key.
   std::string channel_id;
+  QuicTag token_binding_key_param;
 
   // Used when generating proof signature when sending server config updates.
   bool x509_ecdsa_supported;
@@ -179,6 +180,10 @@
   // Authenticated encryption with associated data (AEAD) algorithms.
   QuicTagVector aead;
 
+  // Supported Token Binding key parameters that can be negotiated in the client
+  // hello.
+  QuicTagVector tb_key_params;
+
   const CommonCertSets* common_cert_sets;
 
  private:
diff --git a/net/quic/crypto/crypto_handshake_message.cc b/net/quic/crypto/crypto_handshake_message.cc
index 9cf25ad..d45b6aa1 100644
--- a/net/quic/crypto/crypto_handshake_message.cc
+++ b/net/quic/crypto/crypto_handshake_message.cc
@@ -249,6 +249,7 @@
           done = true;
         }
         break;
+      case kTBKP:
       case kKEXS:
       case kAEAD:
       case kCOPT:
diff --git a/net/quic/crypto/crypto_protocol.h b/net/quic/crypto/crypto_protocol.h
index 18dbc0c..84120805 100644
--- a/net/quic/crypto/crypto_protocol.h
+++ b/net/quic/crypto/crypto_protocol.h
@@ -147,6 +147,7 @@
                                                  // flow control receive window.
 const QuicTag kUAID = TAG('U', 'A', 'I', 'D');   // Client's User Agent ID.
 const QuicTag kXLCT = TAG('X', 'L', 'C', 'T');   // Expected leaf certificate.
+const QuicTag kTBKP = TAG('T', 'B', 'K', 'P');   // Token Binding key params.
 
 // Rejection tags
 const QuicTag kRREJ = TAG('R', 'R', 'E', 'J');   // Reasons for server sending
diff --git a/net/quic/crypto/crypto_utils.cc b/net/quic/crypto/crypto_utils.cc
index 555a2b9..67c1c38 100644
--- a/net/quic/crypto/crypto_utils.cc
+++ b/net/quic/crypto/crypto_utils.cc
@@ -201,4 +201,38 @@
   return QUIC_NO_ERROR;
 }
 
+QuicErrorCode CryptoUtils::ValidateClientHello(
+    const CryptoHandshakeMessage& client_hello,
+    QuicVersion version,
+    const QuicVersionVector& supported_versions,
+    string* error_details) {
+  if (client_hello.tag() != kCHLO) {
+    *error_details = "Bad tag";
+    return QUIC_INVALID_CRYPTO_MESSAGE_TYPE;
+  }
+
+  // If the client's preferred version is not the version we are currently
+  // speaking, then the client went through a version negotiation.  In this
+  // case, we need to make sure that we actually do not support this version
+  // and that it wasn't a downgrade attack.
+  QuicTag client_version_tag;
+  if (client_hello.GetUint32(kVER, &client_version_tag) != QUIC_NO_ERROR) {
+    *error_details = "client hello missing version list";
+    return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
+  }
+  QuicVersion client_version = QuicTagToQuicVersion(client_version_tag);
+  if (client_version != version) {
+    // Just because client_version is a valid version enum doesn't mean that
+    // this server actually supports that version, so we check to see if
+    // it's actually in the supported versions list.
+    for (size_t i = 0; i < supported_versions.size(); ++i) {
+      if (client_version == supported_versions[i]) {
+        *error_details = "Downgrade attack detected";
+        return QUIC_VERSION_NEGOTIATION_MISMATCH;
+      }
+    }
+  }
+  return QUIC_NO_ERROR;
+}
+
 }  // namespace net
diff --git a/net/quic/crypto/crypto_utils.h b/net/quic/crypto/crypto_utils.h
index ff9c951..6d40074 100644
--- a/net/quic/crypto/crypto_utils.h
+++ b/net/quic/crypto/crypto_utils.h
@@ -85,6 +85,18 @@
       const QuicVersionVector& negotiated_versions,
       std::string* error_details);
 
+  // Validates that |client_hello| is actually a CHLO and that this is not part
+  // of a downgrade attack.
+  // This includes verifiying versions and detecting downgrade attacks.
+  //
+  // Returns QUIC_NO_ERROR if this is the case or returns the appropriate error
+  // code and sets |error_details|.
+  static QuicErrorCode ValidateClientHello(
+      const CryptoHandshakeMessage& client_hello,
+      QuicVersion version,
+      const QuicVersionVector& supported_versions,
+      std::string* error_details);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CryptoUtils);
 };
diff --git a/net/quic/crypto/proof_test.cc b/net/quic/crypto/proof_test.cc
index d24c9e0..3a7db6fb 100644
--- a/net/quic/crypto/proof_test.cc
+++ b/net/quic/crypto/proof_test.cc
@@ -72,7 +72,7 @@
       new TestProofVerifierCallback(&comp_callback, &ok, &error_details);
 
   QuicAsyncStatus status = verifier->VerifyProof(
-      hostname, server_config, certs, proof, verify_context.get(),
+      hostname, server_config, certs, "", proof, verify_context.get(),
       &error_details, &details, callback);
 
   switch (status) {
diff --git a/net/quic/crypto/proof_verifier.h b/net/quic/crypto/proof_verifier.h
index 87339da4..0ec346a 100644
--- a/net/quic/crypto/proof_verifier.h
+++ b/net/quic/crypto/proof_verifier.h
@@ -76,6 +76,7 @@
   virtual QuicAsyncStatus VerifyProof(const std::string& hostname,
                                       const std::string& server_config,
                                       const std::vector<std::string>& certs,
+                                      const std::string& cert_sct,
                                       const std::string& signature,
                                       const ProofVerifyContext* context,
                                       std::string* error_details,
diff --git a/net/quic/crypto/proof_verifier_chromium.cc b/net/quic/crypto/proof_verifier_chromium.cc
index 8defdad..68f2286 100644
--- a/net/quic/crypto/proof_verifier_chromium.cc
+++ b/net/quic/crypto/proof_verifier_chromium.cc
@@ -58,6 +58,7 @@
   QuicAsyncStatus VerifyProof(const std::string& hostname,
                               const std::string& server_config,
                               const std::vector<std::string>& certs,
+                              const std::string& cert_sct,
                               const std::string& signature,
                               std::string* error_details,
                               scoped_ptr<ProofVerifyDetails>* verify_details,
@@ -130,6 +131,7 @@
     const string& hostname,
     const string& server_config,
     const vector<string>& certs,
+    const std::string& cert_sct,
     const string& signature,
     std::string* error_details,
     scoped_ptr<ProofVerifyDetails>* verify_details,
@@ -382,6 +384,7 @@
     const std::string& hostname,
     const std::string& server_config,
     const std::vector<std::string>& certs,
+    const std::string& cert_sct,
     const std::string& signature,
     const ProofVerifyContext* verify_context,
     std::string* error_details,
@@ -397,8 +400,8 @@
       this, cert_verifier_, cert_policy_enforcer_, transport_security_state_,
       chromium_context->cert_verify_flags, chromium_context->net_log));
   QuicAsyncStatus status =
-      job->VerifyProof(hostname, server_config, certs, signature, error_details,
-                       verify_details, callback);
+      job->VerifyProof(hostname, server_config, certs, cert_sct, signature,
+                       error_details, verify_details, callback);
   if (status == QUIC_PENDING) {
     active_jobs_.insert(job.release());
   }
diff --git a/net/quic/crypto/proof_verifier_chromium.h b/net/quic/crypto/proof_verifier_chromium.h
index 46d63e1..77a6714 100644
--- a/net/quic/crypto/proof_verifier_chromium.h
+++ b/net/quic/crypto/proof_verifier_chromium.h
@@ -65,6 +65,7 @@
   QuicAsyncStatus VerifyProof(const std::string& hostname,
                               const std::string& server_config,
                               const std::vector<std::string>& certs,
+                              const std::string& cert_sct,
                               const std::string& signature,
                               const ProofVerifyContext* verify_context,
                               std::string* error_details,
diff --git a/net/quic/crypto/proof_verifier_chromium_test.cc b/net/quic/crypto/proof_verifier_chromium_test.cc
index 9e0f598..9a7f0db 100644
--- a/net/quic/crypto/proof_verifier_chromium_test.cc
+++ b/net/quic/crypto/proof_verifier_chromium_test.cc
@@ -161,7 +161,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, GetTestSignature(),
+      kTestHostname, kTestConfig, certs, "", GetTestSignature(),
       verify_context.get(), &error_details, &details, callback);
   ASSERT_EQ(QUIC_FAILURE, status);
   delete callback;
@@ -183,7 +183,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, kTestConfig, verify_context.get(),
+      kTestHostname, kTestConfig, certs, "", kTestConfig, verify_context.get(),
       &error_details, &details, callback);
   ASSERT_EQ(QUIC_FAILURE, status);
   delete callback;
@@ -214,7 +214,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, GetTestSignature(),
+      kTestHostname, kTestConfig, certs, "", GetTestSignature(),
       verify_context.get(), &error_details, &details, callback);
   ASSERT_EQ(QUIC_SUCCESS, status);
   delete callback;
@@ -254,7 +254,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, GetTestSignature(),
+      kTestHostname, kTestConfig, certs, "", GetTestSignature(),
       verify_context.get(), &error_details, &details, callback);
   ASSERT_EQ(QUIC_SUCCESS, status);
   delete callback;
@@ -294,7 +294,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, GetTestSignature(),
+      kTestHostname, kTestConfig, certs, "", GetTestSignature(),
       verify_context.get(), &error_details, &details, callback);
   ASSERT_EQ(QUIC_SUCCESS, status);
   delete callback;
@@ -335,7 +335,7 @@
 
   DummyProofVerifierCallback* callback = new DummyProofVerifierCallback;
   QuicAsyncStatus status = proof_verifier.VerifyProof(
-      kTestHostname, kTestConfig, certs, GetTestSignature(),
+      kTestHostname, kTestConfig, certs, "", GetTestSignature(),
       verify_context.get(), &error_details, &details, callback);
   ASSERT_EQ(QUIC_SUCCESS, status);
   delete callback;
diff --git a/net/quic/crypto/quic_crypto_client_config.cc b/net/quic/crypto/quic_crypto_client_config.cc
index b9b0bcd4..0eb5e371 100644
--- a/net/quic/crypto/quic_crypto_client_config.cc
+++ b/net/quic/crypto/quic_crypto_client_config.cc
@@ -188,6 +188,7 @@
 }
 
 void QuicCryptoClientConfig::CachedState::SetProof(const vector<string>& certs,
+                                                   StringPiece cert_sct,
                                                    StringPiece signature) {
   bool has_changed =
       signature != server_config_sig_ || certs_.size() != certs.size();
@@ -208,6 +209,7 @@
   // If the proof has changed then it needs to be revalidated.
   SetProofInvalid();
   certs_ = certs;
+  cert_sct_ = cert_sct.as_string();
   server_config_sig_ = signature.as_string();
 }
 
@@ -215,6 +217,7 @@
   server_config_.clear();
   source_address_token_.clear();
   certs_.clear();
+  cert_sct_.clear();
   server_config_sig_.clear();
   server_config_valid_ = false;
   proof_verify_details_.reset();
@@ -227,6 +230,7 @@
 void QuicCryptoClientConfig::CachedState::ClearProof() {
   SetProofInvalid();
   certs_.clear();
+  cert_sct_.clear();
   server_config_sig_.clear();
 }
 
@@ -243,6 +247,7 @@
     StringPiece server_config,
     StringPiece source_address_token,
     const vector<string>& certs,
+    const string& cert_sct,
     StringPiece signature,
     QuicWallTime now) {
   DCHECK(server_config_.empty());
@@ -264,6 +269,7 @@
   signature.CopyToString(&server_config_sig_);
   source_address_token.CopyToString(&source_address_token_);
   certs_ = certs;
+  cert_sct_ = cert_sct;
   return true;
 }
 
@@ -280,6 +286,10 @@
   return certs_;
 }
 
+const string& QuicCryptoClientConfig::CachedState::cert_sct() const {
+  return cert_sct_;
+}
+
 const string& QuicCryptoClientConfig::CachedState::signature() const {
   return server_config_sig_;
 }
@@ -302,6 +312,10 @@
   source_address_token_ = token.as_string();
 }
 
+void QuicCryptoClientConfig::CachedState::set_cert_sct(StringPiece cert_sct) {
+  cert_sct_ = cert_sct.as_string();
+}
+
 void QuicCryptoClientConfig::CachedState::SetProofVerifyDetails(
     ProofVerifyDetails* details) {
   proof_verify_details_.reset(details);
@@ -314,6 +328,7 @@
   server_config_ = other.server_config_;
   source_address_token_ = other.source_address_token_;
   certs_ = other.certs_;
+  cert_sct_ = other.cert_sct_;
   server_config_sig_ = other.server_config_sig_;
   server_config_valid_ = other.server_config_valid_;
   server_designated_connection_ids_ = other.server_designated_connection_ids_;
@@ -419,6 +434,10 @@
     out->SetStringPiece(kCCS, common_cert_sets->GetCommonHashes());
   }
 
+  if (preferred_version > QUIC_VERSION_29) {
+    out->SetStringPiece(kCertificateSCTTag, "");
+  }
+
   const vector<string>& certs = cached->certs();
   // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
   // client config is being used for multiple connections, another connection
@@ -467,6 +486,10 @@
   }
   out->SetStringPiece(kSCID, scid);
 
+  if (preferred_version > QUIC_VERSION_29) {
+    out->SetStringPiece(kCertificateSCTTag, "");
+  }
+
   const QuicTag* their_aeads;
   const QuicTag* their_key_exchanges;
   size_t num_their_aeads, num_their_key_exchanges;
@@ -497,6 +520,26 @@
   out->SetTaglist(kAEAD, out_params->aead, 0);
   out->SetTaglist(kKEXS, out_params->key_exchange, 0);
 
+  if (!tb_key_params.empty()) {
+    const QuicTag* their_tbkps;
+    size_t num_their_tbkps;
+    switch (scfg->GetTaglist(kTBKP, &their_tbkps, &num_their_tbkps)) {
+      case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
+        break;
+      case QUIC_NO_ERROR:
+        if (QuicUtils::FindMutualTag(tb_key_params, their_tbkps,
+                                     num_their_tbkps, QuicUtils::LOCAL_PRIORITY,
+                                     &out_params->token_binding_key_param,
+                                     nullptr)) {
+          out->SetTaglist(kTBKP, out_params->token_binding_key_param, 0);
+        }
+        break;
+      default:
+        *error_details = "Invalid TBKP";
+        return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
+    }
+  }
+
   StringPiece public_value;
   if (scfg->GetNthValue24(kPUBS, key_exchange_index, &public_value) !=
           QUIC_NO_ERROR) {
@@ -645,6 +688,7 @@
 QuicErrorCode QuicCryptoClientConfig::CacheNewServerConfig(
     const CryptoHandshakeMessage& message,
     QuicWallTime now,
+    const QuicVersion version,
     const vector<string>& cached_certs,
     CachedState* cached,
     string* error_details) {
@@ -672,7 +716,7 @@
     cached->set_source_address_token(token);
   }
 
-  StringPiece proof, cert_bytes;
+  StringPiece proof, cert_bytes, cert_sct;
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
@@ -683,7 +727,10 @@
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
-    cached->SetProof(certs, proof);
+    if (version > QUIC_VERSION_29) {
+      message.GetStringPiece(kCertificateSCTTag, &cert_sct);
+    }
+    cached->SetProof(certs, cert_sct, proof);
   } else {
     // Secure QUIC: clear existing proof as we have been sent a new SCFG
     // without matching proof/certs.
@@ -706,6 +753,7 @@
 QuicErrorCode QuicCryptoClientConfig::ProcessRejection(
     const CryptoHandshakeMessage& rej,
     QuicWallTime now,
+    const QuicVersion version,
     CachedState* cached,
     QuicCryptoNegotiatedParameters* out_params,
     string* error_details) {
@@ -716,8 +764,8 @@
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
-  QuicErrorCode error = CacheNewServerConfig(rej, now, out_params->cached_certs,
-                                             cached, error_details);
+  QuicErrorCode error = CacheNewServerConfig(
+      rej, now, version, out_params->cached_certs, cached, error_details);
   if (error != QUIC_NO_ERROR) {
     return error;
   }
@@ -829,6 +877,7 @@
 QuicErrorCode QuicCryptoClientConfig::ProcessServerConfigUpdate(
     const CryptoHandshakeMessage& server_config_update,
     QuicWallTime now,
+    const QuicVersion version,
     CachedState* cached,
     QuicCryptoNegotiatedParameters* out_params,
     string* error_details) {
@@ -838,8 +887,7 @@
     *error_details = "ServerConfigUpdate must have kSCUP tag.";
     return QUIC_INVALID_CRYPTO_MESSAGE_TYPE;
   }
-
-  return CacheNewServerConfig(server_config_update, now,
+  return CacheNewServerConfig(server_config_update, now, version,
                               out_params->cached_certs, cached, error_details);
 }
 
diff --git a/net/quic/crypto/quic_crypto_client_config.h b/net/quic/crypto/quic_crypto_client_config.h
index 3ab50954..6a2085f 100644
--- a/net/quic/crypto/quic_crypto_client_config.h
+++ b/net/quic/crypto/quic_crypto_client_config.h
@@ -82,6 +82,7 @@
 
     // SetProof stores a certificate chain and signature.
     void SetProof(const std::vector<std::string>& certs,
+                  base::StringPiece cert_sct,
                   base::StringPiece signature);
 
     // Clears all the data.
@@ -103,6 +104,7 @@
     const std::string& server_config() const;
     const std::string& source_address_token() const;
     const std::vector<std::string>& certs() const;
+    const std::string& cert_sct() const;
     const std::string& signature() const;
     bool proof_valid() const;
     uint64 generation_counter() const;
@@ -110,6 +112,8 @@
 
     void set_source_address_token(base::StringPiece token);
 
+    void set_cert_sct(base::StringPiece cert_sct);
+
     // Adds the connection ID to the queue of server-designated connection-ids.
     void add_server_designated_connection_id(QuicConnectionId connection_id);
 
@@ -150,6 +154,7 @@
     bool Initialize(base::StringPiece server_config,
                     base::StringPiece source_address_token,
                     const std::vector<std::string>& certs,
+                    const std::string& cert_sct,
                     base::StringPiece signature,
                     QuicWallTime now);
 
@@ -158,6 +163,7 @@
     std::string source_address_token_;  // An opaque proof of IP ownership.
     std::vector<std::string> certs_;    // A list of certificates in leaf-first
                                         // order.
+    std::string cert_sct_;              // Signed timestamp of the leaf cert.
     std::string server_config_sig_;     // A signature of |server_config_|.
     bool server_config_valid_;          // True if |server_config_| is correctly
                                         // signed and |certs_| has been
@@ -238,6 +244,7 @@
   // reject reason for secure vs insecure QUIC.
   QuicErrorCode ProcessRejection(const CryptoHandshakeMessage& rej,
                                  QuicWallTime now,
+                                 QuicVersion version,
                                  CachedState* cached,
                                  QuicCryptoNegotiatedParameters* out_params,
                                  std::string* error_details);
@@ -267,6 +274,7 @@
   QuicErrorCode ProcessServerConfigUpdate(
       const CryptoHandshakeMessage& server_update,
       QuicWallTime now,
+      const QuicVersion version,
       CachedState* cached,
       QuicCryptoNegotiatedParameters* out_params,
       std::string* error_details);
@@ -322,6 +330,7 @@
   QuicErrorCode CacheNewServerConfig(
       const CryptoHandshakeMessage& message,
       QuicWallTime now,
+      const QuicVersion version,
       const std::vector<std::string>& cached_certs,
       CachedState* cached,
       std::string* error_details);
diff --git a/net/quic/crypto/quic_crypto_client_config_test.cc b/net/quic/crypto/quic_crypto_client_config_test.cc
index 205ebf84..238011f 100644
--- a/net/quic/crypto/quic_crypto_client_config_test.cc
+++ b/net/quic/crypto/quic_crypto_client_config_test.cc
@@ -319,7 +319,7 @@
   // TODO(rch): Populate other fields of |state|.
   vector<string> certs(1);
   certs[0] = "Hello Cert";
-  state->SetProof(certs, "signature");
+  state->SetProof(certs, "cert_sct", "signature");
   state->set_source_address_token("TOKEN");
   state->SetProofValid();
   EXPECT_EQ(1u, state->generation_counter());
@@ -341,6 +341,7 @@
   EXPECT_FALSE(cleared_cache->proof_valid());
   EXPECT_TRUE(cleared_cache->server_config().empty());
   EXPECT_TRUE(cleared_cache->certs().empty());
+  EXPECT_TRUE(cleared_cache->cert_sct().empty());
   EXPECT_TRUE(cleared_cache->signature().empty());
   EXPECT_EQ(2u, cleared_cache->generation_counter());
 }
@@ -388,9 +389,10 @@
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(QUIC_NO_ERROR, config.ProcessRejection(
-                               rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                               &out_params, &error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_FALSE(cached.has_server_designated_connection_id());
   EXPECT_FALSE(cached.has_server_nonce());
 }
@@ -409,9 +411,10 @@
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(QUIC_NO_ERROR, config.ProcessRejection(
-                               rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                               &out_params, &error));
+  EXPECT_EQ(QUIC_NO_ERROR,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_TRUE(cached.has_server_designated_connection_id());
   EXPECT_EQ(kConnectionId, cached.GetNextServerDesignatedConnectionId());
   EXPECT_EQ(server_nonce, cached.GetNextServerNonce());
@@ -428,10 +431,10 @@
   QuicCryptoNegotiatedParameters out_params;
   string error;
   QuicCryptoClientConfig config(CryptoTestUtils::ProofVerifierForTesting());
-  EXPECT_EQ(
-      QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
-      config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0), &cached,
-                              &out_params, &error));
+  EXPECT_EQ(QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND,
+            config.ProcessRejection(rej, QuicWallTime::FromUNIXSeconds(0),
+                                    QuicSupportedVersions().front(), &cached,
+                                    &out_params, &error));
   EXPECT_FALSE(cached.has_server_designated_connection_id());
   EXPECT_EQ("Missing kRCID", error);
 }
diff --git a/net/quic/crypto/quic_crypto_server_config.cc b/net/quic/crypto/quic_crypto_server_config.cc
index c523dd4..e4c052f 100644
--- a/net/quic/crypto/quic_crypto_server_config.cc
+++ b/net/quic/crypto/quic_crypto_server_config.cc
@@ -205,6 +205,7 @@
 QuicCryptoServerConfig::ConfigOptions::ConfigOptions()
     : expiry_time(QuicWallTime::Zero()),
       channel_id_enabled(false),
+      token_binding_enabled(false),
       p256(false) {}
 
 QuicCryptoServerConfig::QuicCryptoServerConfig(
@@ -322,6 +323,10 @@
     msg.SetTaglist(kPDMD, kCHID, 0);
   }
 
+  if (options.token_binding_enabled) {
+    msg.SetTaglist(kTBKP, kP256, 0);
+  }
+
   if (options.id.empty()) {
     // We need to ensure that the SCID changes whenever the server config does
     // thus we make it a hash of the rest of the server config.
@@ -547,27 +552,10 @@
       validate_chlo_result.client_hello;
   const ClientHelloInfo& info = validate_chlo_result.info;
 
-  // If the client's preferred version is not the version we are currently
-  // speaking, then the client went through a version negotiation.  In this
-  // case, we need to make sure that we actually do not support this version
-  // and that it wasn't a downgrade attack.
-  QuicTag client_version_tag;
-  if (client_hello.GetUint32(kVER, &client_version_tag) != QUIC_NO_ERROR) {
-    *error_details = "client hello missing version list";
-    return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
-  }
-  QuicVersion client_version = QuicTagToQuicVersion(client_version_tag);
-  if (client_version != version) {
-    // Just because client_version is a valid version enum doesn't mean that
-    // this server actually supports that version, so we check to see if
-    // it's actually in the supported versions list.
-    for (size_t i = 0; i < supported_versions.size(); ++i) {
-      if (client_version == supported_versions[i]) {
-        *error_details = "Downgrade attack detected";
-        return QUIC_VERSION_NEGOTIATION_MISMATCH;
-      }
-    }
-  }
+  QuicErrorCode valid = CryptoUtils::ValidateClientHello(
+      client_hello, version, supported_versions, error_details);
+  if (valid != QUIC_NO_ERROR)
+    return valid;
 
   StringPiece requested_scid;
   client_hello.GetStringPiece(kSCID, &requested_scid);
@@ -658,6 +646,25 @@
     return QUIC_CRYPTO_NO_SUPPORT;
   }
 
+  if (!requested_config->tb_key_params.empty()) {
+    const QuicTag* their_tbkps;
+    size_t num_their_tbkps;
+    switch (client_hello.GetTaglist(kTBKP, &their_tbkps, &num_their_tbkps)) {
+      case QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND:
+        break;
+      case QUIC_NO_ERROR:
+        if (QuicUtils::FindMutualTag(
+                requested_config->tb_key_params, their_tbkps, num_their_tbkps,
+                QuicUtils::LOCAL_PRIORITY, &params->token_binding_key_param,
+                nullptr)) {
+          break;
+        }
+      default:
+        *error_details = "Invalid Token Binding key parameter";
+        return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
+    }
+  }
+
   StringPiece public_value;
   if (!client_hello.GetStringPiece(kPUBS, &public_value)) {
     *error_details = "Missing public value";
@@ -1318,6 +1325,17 @@
     return nullptr;
   }
 
+  const QuicTag* tbkp_tags;
+  size_t tbkp_len;
+  QuicErrorCode err;
+  if ((err = msg->GetTaglist(kTBKP, &tbkp_tags, &tbkp_len)) !=
+          QUIC_CRYPTO_MESSAGE_PARAMETER_NOT_FOUND &&
+      err != QUIC_NO_ERROR) {
+    LOG(WARNING) << "Server config message is missing or has invalid TBKP";
+    return nullptr;
+  }
+  config->tb_key_params = vector<QuicTag>(tbkp_tags, tbkp_tags + tbkp_len);
+
   StringPiece orbit;
   if (!msg->GetStringPiece(kORBT, &orbit)) {
     LOG(WARNING) << "Server config message is missing ORBT";
diff --git a/net/quic/crypto/quic_crypto_server_config.h b/net/quic/crypto/quic_crypto_server_config.h
index 3bf6d7c..c35eca4 100644
--- a/net/quic/crypto/quic_crypto_server_config.h
+++ b/net/quic/crypto/quic_crypto_server_config.h
@@ -125,6 +125,9 @@
     // channel_id_enabled controls whether the server config will indicate
     // support for ChannelIDs.
     bool channel_id_enabled;
+    // token_binding_enabled controls whether the server config will indicate
+    // support for Token Binding.
+    bool token_binding_enabled;
     // id contains the server config id for the resulting config. If empty, a
     // random id is generated.
     std::string id;
diff --git a/net/quic/quic_chromium_client_session_test.cc b/net/quic/quic_chromium_client_session_test.cc
index a2f0eaf..cf7d74e 100644
--- a/net/quic/quic_chromium_client_session_test.cc
+++ b/net/quic/quic_chromium_client_session_test.cc
@@ -91,8 +91,9 @@
   void CompleteCryptoHandshake() {
     ASSERT_EQ(ERR_IO_PENDING,
               session_.CryptoConnect(false, callback_.callback()));
-    CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_,
-                                             session_.GetCryptoStream());
+    CryptoTestUtils::FakeServerOptions server_options;
+    CryptoTestUtils::HandshakeWithFakeServer(
+        &helper_, connection_, session_.GetCryptoStream(), server_options);
     ASSERT_EQ(OK, callback_.WaitForResult());
   }
 
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index fc68aa4c..79d5131 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -1162,6 +1162,12 @@
   packet_generator_.AddControlFrame(QuicFrame(new QuicRstStreamFrame(
       id, AdjustErrorForVersion(error, version()), bytes_written)));
 
+  if (error == QUIC_STREAM_NO_ERROR && version() > QUIC_VERSION_28) {
+    // All data for streams which are reset with QUIC_STREAM_NO_ERROR must
+    // be received by the peer.
+    return;
+  }
+
   sent_packet_manager_.CancelRetransmissionsForStream(id);
   // Remove all queued packets which only contain data for the reset stream.
   QueuedPacketList::iterator packet_iterator = queued_packets_.begin();
@@ -1363,6 +1369,7 @@
              << peer_address_.ToString() << ", migrating connection.";
 
     visitor_->OnConnectionMigration();
+    sent_packet_manager_.OnConnectionMigration(type);
   }
 
   time_of_last_received_packet_ = clock_->Now();
@@ -1467,6 +1474,11 @@
     return false;
   }
 
+  // If the send alarm is set, wait for it to fire.
+  if (FLAGS_respect_send_alarm && send_alarm_->IsSet()) {
+    return false;
+  }
+
   QuicTime now = clock_->Now();
   QuicTime::Delta delay = sent_packet_manager_.TimeUntilSend(
       now, retransmittable);
@@ -1482,7 +1494,9 @@
              << "ms";
     return false;
   }
-  send_alarm_->Cancel();
+  if (!FLAGS_respect_send_alarm) {
+    send_alarm_->Cancel();
+  }
   return true;
 }
 
@@ -1578,8 +1592,8 @@
     // Pass the write result to the visitor.
     debug_visitor_->OnPacketSent(
         packet->serialized_packet, packet->original_packet_number,
-        packet->encryption_level, packet->transmission_type, *encrypted,
-        packet_send_time);
+        packet->encryption_level, packet->transmission_type,
+        encrypted->length(), packet_send_time);
   }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = packet_send_time;
@@ -1979,11 +1993,11 @@
     return;
   }
   connected_ = false;
+  DCHECK(visitor_ != nullptr);
+  visitor_->OnConnectionClosed(error, from_peer);
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnConnectionClosed(error, from_peer);
   }
-  DCHECK(visitor_ != nullptr);
-  visitor_->OnConnectionClosed(error, from_peer);
   // Cancel the alarms so they don't trigger any action now that the
   // connection is closed.
   ack_alarm_->Cancel();
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 6a9d162..45b079c 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -158,7 +158,7 @@
                             QuicPacketNumber original_packet_number,
                             EncryptionLevel level,
                             TransmissionType transmission_type,
-                            const QuicEncryptedPacket& packet,
+                            size_t encrypted_length,
                             QuicTime sent_time) {}
 
   // Called when a packet has been received, but before it is
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc
index d5dc67d5..b1446a4 100644
--- a/net/quic/quic_connection_logger.cc
+++ b/net/quic/quic_connection_logger.cc
@@ -438,13 +438,13 @@
     QuicPacketNumber original_packet_number,
     EncryptionLevel level,
     TransmissionType transmission_type,
-    const QuicEncryptedPacket& packet,
+    size_t encrypted_length,
     QuicTime sent_time) {
   if (original_packet_number == 0) {
     net_log_.AddEvent(
         NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
-        base::Bind(&NetLogQuicPacketSentCallback, serialized_packet,
-                   level, transmission_type, packet.length(), sent_time));
+        base::Bind(&NetLogQuicPacketSentCallback, serialized_packet, level,
+                   transmission_type, encrypted_length, sent_time));
   }  else {
     net_log_.AddEvent(
         NetLog::TYPE_QUIC_SESSION_PACKET_RETRANSMITTED,
diff --git a/net/quic/quic_connection_logger.h b/net/quic/quic_connection_logger.h
index 9e687f2..358bd80 100644
--- a/net/quic/quic_connection_logger.h
+++ b/net/quic/quic_connection_logger.h
@@ -44,7 +44,7 @@
                     QuicPacketNumber original_packet_number,
                     EncryptionLevel level,
                     TransmissionType transmission_type,
-                    const QuicEncryptedPacket& packet,
+                    size_t encrypted_length,
                     QuicTime sent_time) override;
   void OnPacketReceived(const IPEndPoint& self_address,
                         const IPEndPoint& peer_address,
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index e79ed5a..15dd943 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -2426,7 +2426,7 @@
   connection_.SendStreamDataWithString(stream_id, "foo", 0, !kFin, nullptr);
 
   // Now that there is a queued packet, reset the stream.
-  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+  connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
 
   // Unblock the connection and verify that only the RST_STREAM is sent.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
@@ -2436,6 +2436,30 @@
   EXPECT_EQ(1u, writer_->rst_stream_frames().size());
 }
 
+TEST_P(QuicConnectionTest, SendQueuedPacketForQuicRstStreamNoError) {
+  // Block the connection to queue the packet.
+  BlockOnNextWrite();
+
+  QuicStreamId stream_id = 2;
+  connection_.SendStreamDataWithString(stream_id, "foo", 0, !kFin, nullptr);
+
+  // Now that there is a queued packet, reset the stream.
+  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+
+  // Unblock the connection and verify that the RST_STREAM is sent and the data
+  // packet is sent on QUIC_VERSION_29 or later versions.
+  if (version() > QUIC_VERSION_28) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
+        .Times(AtLeast(2));
+  } else {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
+  writer_->SetWritable();
+  connection_.OnCanWrite();
+  EXPECT_EQ(1u, writer_->frame_count());
+  EXPECT_EQ(1u, writer_->rst_stream_frames().size());
+}
+
 TEST_P(QuicConnectionTest, DoNotRetransmitForResetStreamOnNack) {
   QuicStreamId stream_id = 2;
   QuicPacketNumber last_packet;
@@ -2444,7 +2468,7 @@
   SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
-  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+  connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
 
   // Lose a packet and ensure it does not trigger retransmission.
   QuicAckFrame nack_two = InitAckFrame(last_packet);
@@ -2459,16 +2483,68 @@
   ProcessAckPacket(&nack_two);
 }
 
+TEST_P(QuicConnectionTest, RetransmitForQuicRstStreamNoErrorOnNack) {
+  QuicStreamId stream_id = 2;
+  QuicPacketNumber last_packet;
+  SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
+  SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
+  SendStreamDataToPeer(stream_id, "fooos", 7, !kFin, &last_packet);
+
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+
+  // Lose a packet, ensure it triggers retransmission on QUIC_VERSION_29
+  // or later versions.
+  QuicAckFrame nack_two = InitAckFrame(last_packet);
+  NackPacket(last_packet - 1, &nack_two);
+  PacketNumberSet lost_packets;
+  lost_packets.insert(last_packet - 1);
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
+      .WillOnce(Return(lost_packets));
+  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
+  if (version() > QUIC_VERSION_28) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
+        .Times(AtLeast(1));
+  } else {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
+  }
+  ProcessAckPacket(&nack_two);
+}
+
 TEST_P(QuicConnectionTest, DoNotRetransmitForResetStreamOnRTO) {
   QuicStreamId stream_id = 2;
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
 
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
+
+  // Fire the RTO and verify that the RST_STREAM is resent, not stream data.
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  clock_.AdvanceTime(DefaultRetransmissionTime());
+  connection_.GetRetransmissionAlarm()->Fire();
+  EXPECT_EQ(1u, writer_->frame_count());
+  EXPECT_EQ(1u, writer_->rst_stream_frames().size());
+  EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
+}
+
+TEST_P(QuicConnectionTest, RetransmitForQuicRstStreamNoErrorOnRTO) {
+  QuicStreamId stream_id = 2;
+  QuicPacketNumber last_packet;
+  SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
+
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
 
-  // Fire the RTO and verify that the RST_STREAM is resent, not stream data.
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  // Fire the RTO and verify that the RST_STREAM is resent, the stream data
+  // is only sent on QUIC_VERSION_29 or later versions.
+  if (version() > QUIC_VERSION_28) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
+        .Times(AtLeast(2));
+  } else {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
   clock_.AdvanceTime(DefaultRetransmissionTime());
   connection_.GetRetransmissionAlarm()->Fire();
   EXPECT_EQ(1u, writer_->frame_count());
@@ -2496,7 +2572,7 @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   ProcessAckPacket(&ack);
 
-  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+  connection_.SendRstStream(stream_id, QUIC_ERROR_PROCESSING_STREAM, 14);
 
   // Unblock the connection and verify that the RST_STREAM is sent but not the
   // second data packet nor a retransmit.
@@ -2508,6 +2584,48 @@
   EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
 }
 
+TEST_P(QuicConnectionTest, SendPendingRetransmissionForQuicRstStreamNoError) {
+  QuicStreamId stream_id = 2;
+  QuicPacketNumber last_packet;
+  SendStreamDataToPeer(stream_id, "foo", 0, !kFin, &last_packet);
+  SendStreamDataToPeer(stream_id, "foos", 3, !kFin, &last_packet);
+  BlockOnNextWrite();
+  connection_.SendStreamDataWithString(stream_id, "fooos", 7, !kFin, nullptr);
+
+  // Lose a packet which will trigger a pending retransmission.
+  QuicAckFrame ack = InitAckFrame(last_packet);
+  NackPacket(last_packet - 1, &ack);
+  PacketNumberSet lost_packets;
+  lost_packets.insert(last_packet - 1);
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
+      .WillOnce(Return(lost_packets));
+  EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
+  ProcessAckPacket(&ack);
+
+  connection_.SendRstStream(stream_id, QUIC_STREAM_NO_ERROR, 14);
+
+  // Unblock the connection and verify that the RST_STREAM is sent and the
+  // second data packet or a retransmit is only sent on QUIC_VERSION_29 or
+  // later versions.
+  if (version() > QUIC_VERSION_28) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
+        .Times(AtLeast(2));
+  } else {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
+  }
+  writer_->SetWritable();
+  connection_.OnCanWrite();
+  EXPECT_EQ(1u, writer_->frame_count());
+  if (version() > QUIC_VERSION_28) {
+    EXPECT_EQ(0u, writer_->rst_stream_frames().size());
+  } else {
+    EXPECT_EQ(1u, writer_->rst_stream_frames().size());
+    EXPECT_EQ(stream_id, writer_->rst_stream_frames().front().stream_id);
+  }
+}
+
 TEST_P(QuicConnectionTest, DiscardRetransmit) {
   QuicPacketNumber last_packet;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
@@ -4551,24 +4669,17 @@
   QuicConnectionPeer::GetFramer(&connection_)->set_version_for_tests(
       QUIC_VERSION_UNSUPPORTED);
 
-  QuicPacketHeader header;
-  header.public_header.connection_id = connection_id_;
-  header.public_header.version_flag = true;
-  header.packet_number = 12;
-
-  QuicVersionVector supported_versions;
-  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
-    supported_versions.push_back(kSupportedQuicVersions[i]);
-  }
-
   // Send a version negotiation packet.
   scoped_ptr<QuicEncryptedPacket> encrypted(
-      framer_.BuildVersionNegotiationPacket(
-          header.public_header, supported_versions));
+      framer_.BuildVersionNegotiationPacket(connection_id_,
+                                            QuicSupportedVersions()));
   connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
 
   // Now force another packet.  The connection should transition into
   // NEGOTIATED_VERSION state and tell the packet creator to StopSendingVersion.
+  QuicPacketHeader header;
+  header.public_header.connection_id = connection_id_;
+  header.packet_number = 12;
   header.public_header.version_flag = false;
   QuicFrames frames;
   frames.push_back(QuicFrame(&frame1_));
@@ -4587,24 +4698,14 @@
 }
 
 TEST_P(QuicConnectionTest, BadVersionNegotiation) {
-  QuicPacketHeader header;
-  header.public_header.connection_id = connection_id_;
-  header.public_header.version_flag = true;
-  header.packet_number = 12;
-
-  QuicVersionVector supported_versions;
-  for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
-    supported_versions.push_back(kSupportedQuicVersions[i]);
-  }
-
   // Send a version negotiation packet with the version the client started with.
   // It should be rejected.
   EXPECT_CALL(visitor_,
               OnConnectionClosed(QUIC_INVALID_VERSION_NEGOTIATION_PACKET,
                                  false));
   scoped_ptr<QuicEncryptedPacket> encrypted(
-      framer_.BuildVersionNegotiationPacket(
-          header.public_header, supported_versions));
+      framer_.BuildVersionNegotiationPacket(connection_id_,
+                                            QuicSupportedVersions()));
   connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, *encrypted);
 }
 
diff --git a/net/quic/quic_crypto_client_stream.cc b/net/quic/quic_crypto_client_stream.cc
index 98668e2..7783a257 100644
--- a/net/quic/quic_crypto_client_stream.cc
+++ b/net/quic/quic_crypto_client_stream.cc
@@ -155,10 +155,8 @@
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_id_);
   QuicErrorCode error = crypto_config_->ProcessServerConfigUpdate(
-      server_config_update,
-      session()->connection()->clock()->WallNow(),
-      cached,
-      &crypto_negotiated_params_,
+      server_config_update, session()->connection()->clock()->WallNow(),
+      session()->connection()->version(), cached, &crypto_negotiated_params_,
       &error_details);
 
   if (error != QUIC_NO_ERROR) {
@@ -370,8 +368,9 @@
   stateless_reject_received_ = in->tag() == kSREJ;
   string error_details;
   QuicErrorCode error = crypto_config_->ProcessRejection(
-      *in, session()->connection()->clock()->WallNow(), cached,
-      &crypto_negotiated_params_, &error_details);
+      *in, session()->connection()->clock()->WallNow(),
+      session()->connection()->version(), cached, &crypto_negotiated_params_,
+      &error_details);
 
   if (error != QUIC_NO_ERROR) {
     next_state_ = STATE_NONE;
@@ -406,8 +405,8 @@
 
   QuicAsyncStatus status = verifier->VerifyProof(
       server_id_.host(), cached->server_config(), cached->certs(),
-      cached->signature(), verify_context_.get(), &verify_error_details_,
-      &verify_details_, proof_verify_callback);
+      cached->cert_sct(), cached->signature(), verify_context_.get(),
+      &verify_error_details_, &verify_details_, proof_verify_callback);
 
   switch (status) {
     case QUIC_PENDING:
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index eccf3392..8c88880 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -46,7 +46,8 @@
 
   void CompleteCryptoHandshake() {
     stream()->CryptoConnect();
-    CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_, stream());
+    CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_, stream(),
+                                             server_options_);
   }
 
   void ConstructHandshakeMessage() {
@@ -63,6 +64,7 @@
   CryptoHandshakeMessage message_;
   scoped_ptr<QuicData> message_data_;
   QuicCryptoClientConfig crypto_config_;
+  CryptoTestUtils::FakeServerOptions server_options_;
 };
 
 TEST_F(QuicCryptoClientStreamTest, NotInitiallyConected) {
@@ -195,6 +197,42 @@
                                           /*offset=*/0, data->AsStringPiece()));
 }
 
+TEST_F(QuicCryptoClientStreamTest, TokenBindingNegotiation) {
+  server_options_.token_binding_enabled = true;
+  crypto_config_.tb_key_params.push_back(kP256);
+
+  CompleteCryptoHandshake();
+  EXPECT_TRUE(stream()->encryption_established());
+  EXPECT_TRUE(stream()->handshake_confirmed());
+  EXPECT_EQ(kP256,
+            stream()->crypto_negotiated_params().token_binding_key_param);
+}
+
+TEST_F(QuicCryptoClientStreamTest, NoTokenBindingWithoutServerSupport) {
+  crypto_config_.tb_key_params.push_back(kP256);
+
+  CompleteCryptoHandshake();
+  EXPECT_TRUE(stream()->encryption_established());
+  EXPECT_TRUE(stream()->handshake_confirmed());
+  EXPECT_EQ(0u, stream()->crypto_negotiated_params().token_binding_key_param);
+}
+
+TEST_F(QuicCryptoClientStreamTest, NoTokenBindingWithoutClientSupport) {
+  server_options_.token_binding_enabled = true;
+
+  CompleteCryptoHandshake();
+  EXPECT_TRUE(stream()->encryption_established());
+  EXPECT_TRUE(stream()->handshake_confirmed());
+  EXPECT_EQ(0u, stream()->crypto_negotiated_params().token_binding_key_param);
+}
+
+TEST_F(QuicCryptoClientStreamTest, TokenBindingNotNegotiated) {
+  CompleteCryptoHandshake();
+  EXPECT_TRUE(stream()->encryption_established());
+  EXPECT_TRUE(stream()->handshake_confirmed());
+  EXPECT_EQ(0u, stream()->crypto_negotiated_params().token_binding_key_param);
+}
+
 class QuicCryptoClientStreamStatelessTest : public ::testing::Test {
  public:
   QuicCryptoClientStreamStatelessTest()
@@ -232,9 +270,10 @@
                                &server_connection_, &server_session);
     CHECK(server_session);
     server_session_.reset(server_session);
+    CryptoTestUtils::FakeServerOptions options;
     CryptoTestUtils::SetupCryptoServerConfigForTest(
         server_connection_->clock(), server_connection_->random_generator(),
-        server_session_->config(), &server_crypto_config_);
+        server_session_->config(), &server_crypto_config_, options);
     FLAGS_enable_quic_stateless_reject_support = true;
   }
 
@@ -265,8 +304,8 @@
   InitializeFakeStatelessRejectServer();
   AdvanceHandshakeWithFakeServer();
 
-  EXPECT_EQ(1, server_stream()->num_handshake_messages());
-  EXPECT_EQ(0, server_stream()->num_handshake_messages_with_server_nonces());
+  EXPECT_EQ(1, server_stream()->NumHandshakeMessages());
+  EXPECT_EQ(0, server_stream()->NumHandshakeMessagesWithServerNonces());
 
   EXPECT_FALSE(client_session_->GetCryptoStream()->encryption_established());
   EXPECT_FALSE(client_session_->GetCryptoStream()->handshake_confirmed());
diff --git a/net/quic/quic_crypto_server_stream.cc b/net/quic/quic_crypto_server_stream.cc
index 30ba158..8e2e15a 100644
--- a/net/quic/quic_crypto_server_stream.cc
+++ b/net/quic/quic_crypto_server_stream.cc
@@ -32,7 +32,7 @@
 QuicCryptoServerStream::QuicCryptoServerStream(
     const QuicCryptoServerConfig* crypto_config,
     QuicSession* session)
-    : QuicCryptoStream(session),
+    : QuicCryptoServerStreamBase(session),
       crypto_config_(crypto_config),
       validate_client_hello_cb_(nullptr),
       num_handshake_messages_(0),
@@ -57,7 +57,7 @@
 
 void QuicCryptoServerStream::OnHandshakeMessage(
     const CryptoHandshakeMessage& message) {
-  QuicCryptoStream::OnHandshakeMessage(message);
+  QuicCryptoServerStreamBase::OnHandshakeMessage(message);
   ++num_handshake_messages_;
 
   // Do not process handshake messages after the handshake is confirmed.
@@ -110,8 +110,8 @@
 
   if (reply.tag() != kSHLO) {
     if (reply.tag() == kSREJ) {
-      DCHECK(use_stateless_rejects_if_peer_supported());
-      DCHECK(peer_supports_stateless_rejects());
+      DCHECK(use_stateless_rejects_if_peer_supported_);
+      DCHECK(peer_supports_stateless_rejects_);
       // Before sending the SREJ, cause the connection to save crypto packets
       // so that they can be added to the time wait list manager and
       // retransmitted.
@@ -120,8 +120,8 @@
     SendHandshakeMessage(reply);
 
     if (reply.tag() == kSREJ) {
-      DCHECK(use_stateless_rejects_if_peer_supported());
-      DCHECK(peer_supports_stateless_rejects());
+      DCHECK(use_stateless_rejects_if_peer_supported_);
+      DCHECK(peer_supports_stateless_rejects_);
       DCHECK(!handshake_confirmed());
       DVLOG(1) << "Closing connection "
                << session()->connection()->connection_id()
@@ -212,7 +212,37 @@
   session()->connection()->OnHandshakeComplete();
 }
 
-void QuicCryptoServerStream::set_previous_cached_network_params(
+uint8 QuicCryptoServerStream::NumHandshakeMessages() const {
+  return num_handshake_messages_;
+}
+
+uint8 QuicCryptoServerStream::NumHandshakeMessagesWithServerNonces() const {
+  return num_handshake_messages_with_server_nonces_;
+}
+
+int QuicCryptoServerStream::NumServerConfigUpdateMessagesSent() const {
+  return num_server_config_update_messages_sent_;
+}
+
+const CachedNetworkParameters*
+QuicCryptoServerStream::PreviousCachedNetworkParams() const {
+  return previous_cached_network_params_.get();
+}
+
+bool QuicCryptoServerStream::UseStatelessRejectsIfPeerSupported() const {
+  return use_stateless_rejects_if_peer_supported_;
+}
+
+bool QuicCryptoServerStream::PeerSupportsStatelessRejects() const {
+  return peer_supports_stateless_rejects_;
+}
+
+void QuicCryptoServerStream::SetPeerSupportsStatelessRejects(
+    bool peer_supports_stateless_rejects) {
+  peer_supports_stateless_rejects_ = peer_supports_stateless_rejects;
+}
+
+void QuicCryptoServerStream::SetPreviousCachedNetworkParams(
     CachedNetworkParameters cached_network_params) {
   previous_cached_network_params_.reset(
       new CachedNetworkParameters(cached_network_params));
@@ -282,11 +312,6 @@
 void QuicCryptoServerStream::OverrideQuicConfigDefaults(QuicConfig* config) {
 }
 
-const CachedNetworkParameters*
-QuicCryptoServerStream::previous_cached_network_params() const {
-  return previous_cached_network_params_.get();
-}
-
 QuicCryptoServerStream::ValidateCallback::ValidateCallback(
     QuicCryptoServerStream* parent) : parent_(parent) {
 }
diff --git a/net/quic/quic_crypto_server_stream.h b/net/quic/quic_crypto_server_stream.h
index f3d9c92..b07cef40 100644
--- a/net/quic/quic_crypto_server_stream.h
+++ b/net/quic/quic_crypto_server_stream.h
@@ -18,7 +18,7 @@
 class CachedNetworkParameters;
 class CryptoHandshakeMessage;
 class QuicCryptoServerConfig;
-class QuicCryptoServerStream;
+class QuicCryptoServerStreamBase;
 class QuicSession;
 
 namespace test {
@@ -30,7 +30,7 @@
 // peer. At this point we disable HANDSHAKE_MODE in the sent packet manager.
 class NET_EXPORT_PRIVATE ServerHelloNotifier : public QuicAckListenerInterface {
  public:
-  explicit ServerHelloNotifier(QuicCryptoServerStream* stream)
+  explicit ServerHelloNotifier(QuicCryptoServerStreamBase* stream)
       : server_stream_(stream) {}
 
   void OnPacketAcked(int acked_bytes,
@@ -41,65 +41,76 @@
  private:
   ~ServerHelloNotifier() override {}
 
-  QuicCryptoServerStream* server_stream_;
+  QuicCryptoServerStreamBase* server_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerHelloNotifier);
 };
 
-class NET_EXPORT_PRIVATE QuicCryptoServerStream : public QuicCryptoStream {
+// TODO(alyssar) see what can be moved out of QuicCryptoServerStream with
+// various code and test refactoring.
+class NET_EXPORT_PRIVATE QuicCryptoServerStreamBase : public QuicCryptoStream {
+ public:
+  // |crypto_config| must outlive the stream.
+  explicit QuicCryptoServerStreamBase(QuicSession* session)
+      : QuicCryptoStream(session) {}
+  ~QuicCryptoServerStreamBase() override {}
+
+  // Cancel any outstanding callbacks, such as asynchronous validation of client
+  // hello.
+  virtual void CancelOutstandingCallbacks() = 0;
+
+  // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
+  // SHA-256 hash of the client's ChannelID key and returns true, if the client
+  // presented a ChannelID. Otherwise it returns false.
+  virtual bool GetBase64SHA256ClientChannelID(std::string* output) const = 0;
+
+  virtual int NumServerConfigUpdateMessagesSent() const = 0;
+
+  // Sends the latest server config and source-address token to the client.
+  virtual void SendServerConfigUpdate(
+      const CachedNetworkParameters* cached_network_params) = 0;
+
+  // Called by the ServerHello AckNotifier once the SHLO has been ACKed by the
+  // client.
+  virtual void OnServerHelloAcked() = 0;
+
+  // These are all accessors and setters to their respective counters.
+  virtual uint8 NumHandshakeMessages() const = 0;
+  virtual uint8 NumHandshakeMessagesWithServerNonces() const = 0;
+  virtual bool UseStatelessRejectsIfPeerSupported() const = 0;
+  virtual bool PeerSupportsStatelessRejects() const = 0;
+  virtual void SetPeerSupportsStatelessRejects(bool set) = 0;
+  virtual const CachedNetworkParameters* PreviousCachedNetworkParams()
+      const = 0;
+  virtual void SetPreviousCachedNetworkParams(
+      CachedNetworkParameters cached_network_params) = 0;
+};
+
+class NET_EXPORT_PRIVATE QuicCryptoServerStream
+    : public QuicCryptoServerStreamBase {
  public:
   // |crypto_config| must outlive the stream.
   QuicCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
                          QuicSession* session);
   ~QuicCryptoServerStream() override;
 
-  // Cancel any outstanding callbacks, such as asynchronous validation of client
-  // hello.
-  void CancelOutstandingCallbacks();
-
-  // CryptoFramerVisitorInterface implementation
+  // From QuicCryptoServerStreamBase
+  void CancelOutstandingCallbacks() override;
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
-
-  // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
-  // SHA-256 hash of the client's ChannelID key and returns true, if the client
-  // presented a ChannelID. Otherwise it returns false.
-  bool GetBase64SHA256ClientChannelID(std::string* output) const;
-
-  uint8 num_handshake_messages() const { return num_handshake_messages_; }
-
-  uint8 num_handshake_messages_with_server_nonces() const {
-    return num_handshake_messages_with_server_nonces_;
-  }
-
-  int num_server_config_update_messages_sent() const {
-    return num_server_config_update_messages_sent_;
-  }
-
-  // Sends the latest server config and source-address token to the client.
-  virtual void SendServerConfigUpdate(
-      const CachedNetworkParameters* cached_network_params);
-
-  // Called by the ServerHello AckNotifier once the SHLO has been ACKed by the
-  // client.
-  void OnServerHelloAcked();
-
-  void set_previous_cached_network_params(
-      CachedNetworkParameters cached_network_params);
-
-  const CachedNetworkParameters* previous_cached_network_params() const;
-
-  bool use_stateless_rejects_if_peer_supported() const {
-    return use_stateless_rejects_if_peer_supported_;
-  }
-
-  bool peer_supports_stateless_rejects() const {
-    return peer_supports_stateless_rejects_;
-  }
-
-  void set_peer_supports_stateless_rejects(
-      bool peer_supports_stateless_rejects) {
-    peer_supports_stateless_rejects_ = peer_supports_stateless_rejects;
-  }
+  bool GetBase64SHA256ClientChannelID(std::string* output) const override;
+  void SendServerConfigUpdate(
+      const CachedNetworkParameters* cached_network_params) override;
+  void OnServerHelloAcked() override;
+  uint8 NumHandshakeMessages() const override;
+  uint8 NumHandshakeMessagesWithServerNonces() const override;
+  int NumServerConfigUpdateMessagesSent() const override;
+  const CachedNetworkParameters* PreviousCachedNetworkParams() const override;
+  bool UseStatelessRejectsIfPeerSupported() const override;
+  bool PeerSupportsStatelessRejects() const override;
+  void SetPeerSupportsStatelessRejects(
+      bool peer_supports_stateless_rejects) override;
+  void SetPreviousCachedNetworkParams(
+      CachedNetworkParameters cached_network_params) override;
 
  protected:
   virtual QuicErrorCode ProcessClientHello(
diff --git a/net/quic/quic_crypto_server_stream_test.cc b/net/quic/quic_crypto_server_stream_test.cc
index d9bbfe1c..a5bf553 100644
--- a/net/quic/quic_crypto_server_stream_test.cc
+++ b/net/quic/quic_crypto_server_stream_test.cc
@@ -105,9 +105,11 @@
                                &server_connection_, &server_session);
     CHECK(server_session);
     server_session_.reset(server_session);
+    CryptoTestUtils::FakeServerOptions options;
+    options.token_binding_enabled = true;
     CryptoTestUtils::SetupCryptoServerConfigForTest(
         server_connection_->clock(), server_connection_->random_generator(),
-        server_session_->config(), &server_crypto_config_);
+        server_session_->config(), &server_crypto_config_, options);
   }
 
   QuicCryptoServerStream* server_stream() {
@@ -194,8 +196,8 @@
 }
 
 TEST_P(QuicCryptoServerStreamTest, NotInitiallySendingStatelessRejects) {
-  EXPECT_FALSE(server_stream()->use_stateless_rejects_if_peer_supported());
-  EXPECT_FALSE(server_stream()->peer_supports_stateless_rejects());
+  EXPECT_FALSE(server_stream()->UseStatelessRejectsIfPeerSupported());
+  EXPECT_FALSE(server_stream()->PeerSupportsStatelessRejects());
 }
 
 TEST_P(QuicCryptoServerStreamTest, ConnectedAfterCHLO) {
@@ -251,8 +253,8 @@
   // On the first round, encryption will not be established.
   EXPECT_FALSE(server_stream()->encryption_established());
   EXPECT_FALSE(server_stream()->handshake_confirmed());
-  EXPECT_EQ(1, server_stream()->num_handshake_messages());
-  EXPECT_EQ(0, server_stream()->num_handshake_messages_with_server_nonces());
+  EXPECT_EQ(1, server_stream()->NumHandshakeMessages());
+  EXPECT_EQ(0, server_stream()->NumHandshakeMessagesWithServerNonces());
 
   // Now check the client state.
   QuicCryptoClientConfig::CachedState* client_state =
@@ -283,8 +285,8 @@
   // On the second round, encryption will be established.
   EXPECT_TRUE(server_stream()->encryption_established());
   EXPECT_TRUE(server_stream()->handshake_confirmed());
-  EXPECT_EQ(2, server_stream()->num_handshake_messages());
-  EXPECT_EQ(1, server_stream()->num_handshake_messages_with_server_nonces());
+  EXPECT_EQ(2, server_stream()->NumHandshakeMessages());
+  EXPECT_EQ(1, server_stream()->NumHandshakeMessagesWithServerNonces());
 }
 
 TEST_P(QuicCryptoServerStreamTest, NoStatelessRejectIfNoClientSupport) {
@@ -405,7 +407,7 @@
 TEST_P(QuicCryptoServerStreamTest, OnlySendSCUPAfterHandshakeComplete) {
   // An attempt to send a SCUP before completing handshake should fail.
   server_stream()->SendServerConfigUpdate(nullptr);
-  EXPECT_EQ(0, server_stream()->num_server_config_update_messages_sent());
+  EXPECT_EQ(0, server_stream()->NumServerConfigUpdateMessagesSent());
 }
 
 TEST_P(QuicCryptoServerStreamTest, DoesPeerSupportStatelessRejects) {
@@ -422,6 +424,24 @@
       QuicCryptoServerStreamPeer::DoesPeerSupportStatelessRejects(message_));
 }
 
+TEST_P(QuicCryptoServerStreamTest, TokenBindingNegotiated) {
+  client_options_.token_binding_enabled = true;
+  CompleteCryptoHandshake();
+  EXPECT_EQ(
+      kP256,
+      server_stream()->crypto_negotiated_params().token_binding_key_param);
+  EXPECT_TRUE(server_stream()->encryption_established());
+  EXPECT_TRUE(server_stream()->handshake_confirmed());
+}
+
+TEST_P(QuicCryptoServerStreamTest, NoTokenBindingWithoutClientSupport) {
+  CompleteCryptoHandshake();
+  EXPECT_EQ(
+      0u, server_stream()->crypto_negotiated_params().token_binding_key_param);
+  EXPECT_TRUE(server_stream()->encryption_established());
+  EXPECT_TRUE(server_stream()->handshake_confirmed());
+}
+
 }  // namespace
 
 }  // namespace test
diff --git a/net/quic/quic_flags.cc b/net/quic/quic_flags.cc
index fc005c12..0c9baed 100644
--- a/net/quic/quic_flags.cc
+++ b/net/quic/quic_flags.cc
@@ -84,10 +84,6 @@
 // Net.QuicSession.HeadersHOLBlockedTime.
 bool FLAGS_quic_measure_headers_hol_blocking_time = true;
 
-// If true, skip a check for mismatched stream IDs inside
-// ReliableQuicStream::OnStreamFrame.
-bool FLAGS_quic_stop_checking_for_mismatch_ids = true;
-
 // Disable QUIC's userspace pacing.
 bool FLAGS_quic_disable_pacing = false;
 
@@ -119,3 +115,11 @@
 // If true, QUIC connections will timeout when packets are not being recieved,
 // even if they are being sent.
 bool FLAGS_quic_use_new_idle_timeout = true;
+
+// If true, replace QuicFrameList with StreamSequencerBuffer as underlying data
+// structure for QuicStreamSequencer bufferring.
+bool FLAGS_quic_use_stream_sequencer_buffer = true;
+
+// If true, don't send QUIC packets if the send alarm is set.
+// Disabled until b/25638635 is resolved.
+bool FLAGS_respect_send_alarm = false;
diff --git a/net/quic/quic_flags.h b/net/quic/quic_flags.h
index 1d48642..5cf76499 100644
--- a/net/quic/quic_flags.h
+++ b/net/quic/quic_flags.h
@@ -28,7 +28,6 @@
 NET_EXPORT_PRIVATE extern bool FLAGS_allow_many_available_streams;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_read_packets_full_recvmmsg;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_measure_headers_hol_blocking_time;
-NET_EXPORT_PRIVATE extern bool FLAGS_quic_stop_checking_for_mismatch_ids;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_disable_pacing;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_fix_fin_accounting;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_implement_stop_reading;
@@ -37,5 +36,6 @@
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_packet_creator_prefetch;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_disable_non_nat_address_migration;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_use_new_idle_timeout;
-
+NET_EXPORT_PRIVATE extern bool FLAGS_quic_use_stream_sequencer_buffer;
+NET_EXPORT_PRIVATE extern bool FLAGS_respect_send_alarm;
 #endif  // NET_QUIC_QUIC_FLAGS_H_
diff --git a/net/quic/quic_flow_controller.cc b/net/quic/quic_flow_controller.cc
index e2eaf3e..177f0a4 100644
--- a/net/quic/quic_flow_controller.cc
+++ b/net/quic/quic_flow_controller.cc
@@ -11,11 +11,6 @@
 
 namespace net {
 
-namespace {
-const QuicByteCount kStreamReceiveWindowLimit = 16 * 1024 * 1024;   // 16 MB
-const QuicByteCount kSessionReceiveWindowLimit = 24 * 1024 * 1024;  // 24 MB
-}
-
 #define ENDPOINT \
   (perspective_ == Perspective::IS_SERVER ? "Server: " : "Client: ")
 
diff --git a/net/quic/quic_framer.cc b/net/quic/quic_framer.cc
index 1d062fd7..45b9c67 100644
--- a/net/quic/quic_framer.cc
+++ b/net/quic/quic_framer.cc
@@ -477,11 +477,12 @@
   return new QuicEncryptedPacket(buffer.release(), len, true);
 }
 
+// static
 QuicEncryptedPacket* QuicFramer::BuildVersionNegotiationPacket(
-    const QuicPacketPublicHeader& header,
-    const QuicVersionVector& supported_versions) {
-  DCHECK(header.version_flag);
-  size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
+    QuicConnectionId connection_id,
+    const QuicVersionVector& versions) {
+  DCHECK(!versions.empty());
+  size_t len = GetVersionNegotiationPacketSize(versions.size());
   scoped_ptr<char[]> buffer(new char[len]);
   QuicDataWriter writer(len, buffer.get());
 
@@ -491,12 +492,12 @@
     return nullptr;
   }
 
-  if (!writer.WriteUInt64(header.connection_id)) {
+  if (!writer.WriteUInt64(connection_id)) {
     return nullptr;
   }
 
-  for (size_t i = 0; i < supported_versions.size(); ++i) {
-    if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) {
+  for (QuicVersion version : versions) {
+    if (!writer.WriteUInt32(QuicVersionToQuicTag(version))) {
       return nullptr;
     }
   }
diff --git a/net/quic/quic_framer.h b/net/quic/quic_framer.h
index 0bc3299..53ca193 100644
--- a/net/quic/quic_framer.h
+++ b/net/quic/quic_framer.h
@@ -304,9 +304,10 @@
   static QuicEncryptedPacket* BuildPublicResetPacket(
       const QuicPublicResetPacket& packet);
 
-  QuicEncryptedPacket* BuildVersionNegotiationPacket(
-      const QuicPacketPublicHeader& header,
-      const QuicVersionVector& supported_versions);
+  // Returns a new version negotiation packet, owned by the caller.
+  static QuicEncryptedPacket* BuildVersionNegotiationPacket(
+      QuicConnectionId connection_id,
+      const QuicVersionVector& versions);
 
   // SetDecrypter sets the primary decrypter, replacing any that already exists,
   // and takes ownership. If an alternative decrypter is in place then the
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 4a3d3be..4e284a4 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -40,6 +40,17 @@
 const QuicPacketNumber kEpoch = UINT64_C(1) << 48;
 const QuicPacketNumber kMask = kEpoch - 1;
 
+// Use fields in which each byte is distinct to ensure that every byte is
+// framed correctly. The values are otherwise arbitrary.
+const QuicConnectionId kConnectionId = UINT64_C(0xFEDCBA9876543210);
+const QuicPacketNumber kPacketNumber = UINT64_C(0x123456789ABC);
+const QuicPacketNumber kLargestObserved = UINT64_C(0x0123456789ABF);
+const QuicPacketNumber kMissingPacket = UINT64_C(0x0123456789ABE);
+const QuicPacketNumber kLeastUnacked = UINT64_C(0x0123456789AA0);
+const QuicStreamId kStreamId = UINT64_C(0x01020304);
+const QuicStreamOffset kStreamOffset = UINT64_C(0xBA98FEDC32107654);
+const QuicPublicResetNonceProof kNonceProof = UINT64_C(0xABCDEF0123456789);
+
 // Index into the connection_id offset in the header.
 const size_t kConnectionIdOffset = kPublicFlagsSize;
 // Index into the version string in the header. (if present).
@@ -613,8 +624,7 @@
 
   ASSERT_TRUE(visitor_.header_.get());
   // Make sure we've parsed the packet header, so we can send an error.
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   // Make sure the correct error is propagated.
   EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error());
 }
@@ -637,16 +647,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -670,8 +679,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith4ByteConnectionId) {
-  QuicFramerPeer::SetLastSerializedConnectionId(
-      &framer_, UINT64_C(0xFEDCBA9876543210));
+  QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId);
 
   // clang-format off
   unsigned char packet[] = {
@@ -690,16 +698,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -726,8 +733,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeader1ByteConnectionId) {
-  QuicFramerPeer::SetLastSerializedConnectionId(
-      &framer_, UINT64_C(0xFEDCBA9876543210));
+  QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId);
 
   // clang-format off
   unsigned char packet[] = {
@@ -746,16 +752,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -782,8 +787,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) {
-  QuicFramerPeer::SetLastSerializedConnectionId(
-      &framer_, UINT64_C(0xFEDCBA9876543210));
+  QuicFramerPeer::SetLastSerializedConnectionId(&framer_, kConnectionId);
 
   // clang-format off
   unsigned char packet[] = {
@@ -802,16 +806,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -857,17 +860,16 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -893,7 +895,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
+  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
@@ -912,16 +914,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -947,7 +948,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
+  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
@@ -966,16 +967,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -1001,7 +1001,7 @@
 }
 
 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) {
-  QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
+  QuicFramerPeer::SetLastPacketNumber(&framer_, kPacketNumber - 2);
 
   // clang-format off
   unsigned char packet[] = {
@@ -1020,16 +1020,15 @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   // Now test framing boundaries.
   for (size_t i = 0;
@@ -1274,10 +1273,9 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x01020304),
-            visitor_.stream_frames_[0]->stream_id);
+  EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 
   // Now test framing boundaries.
@@ -1323,9 +1321,10 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(UINT64_C(0x00020304), visitor_.stream_frames_[0]->stream_id);
+  // Stream ID should be the last 3 bytes of kStreamId.
+  EXPECT_EQ(0x00FFFFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 
   // Now test framing boundaries.
@@ -1372,10 +1371,10 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x00000304),
-            visitor_.stream_frames_[0]->stream_id);
+  // Stream ID should be the last 2 bytes of kStreamId.
+  EXPECT_EQ(0x0000FFFF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 
   // Now test framing boundaries.
@@ -1422,10 +1421,10 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x00000004),
-            visitor_.stream_frames_[0]->stream_id);
+  // Stream ID should be the last byte of kStreamId.
+  EXPECT_EQ(0x000000FF & kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 
   // Now test framing boundaries.
@@ -1476,10 +1475,9 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(static_cast<uint64>(0x01020304),
-            visitor_.stream_frames_[0]->stream_id);
+  EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 
   // Now test framing boundaries.
@@ -1570,12 +1568,12 @@
   // clang-format on
 
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = true;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   // Do not encrypt the payload because the revived payload is post-encryption.
@@ -1586,22 +1584,21 @@
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_EQ(1, visitor_.revived_packets_);
   ASSERT_TRUE(visitor_.header_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
-            visitor_.header_->public_header.connection_id);
+  EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_TRUE(visitor_.header_->fec_flag);
   EXPECT_TRUE(visitor_.header_->entropy_flag);
   EXPECT_EQ(1 << (header.packet_number % 8), visitor_.header_->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_number);
+  EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(0x00u, visitor_.header_->fec_group);
+  EXPECT_EQ(0u, visitor_.header_->fec_group);
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
+  EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 }
 
@@ -1615,7 +1612,7 @@
     0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
-    0x12, 0x34,
+    0x34, 0x12,
     // private flags (fec group)
     0x02,
     // first fec protected packet offset
@@ -1644,7 +1641,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
   EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
-  EXPECT_EQ(UINT64_C(0x341256789ABA), visitor_.header_->fec_group);
+  EXPECT_EQ(kPacketNumber - 2, visitor_.header_->fec_group);
   const size_t fec_offset = GetStartOfFecProtectedData(
       PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, PACKET_6BYTE_PACKET_NUMBER);
   EXPECT_EQ(
@@ -1653,9 +1650,9 @@
 
   ASSERT_EQ(1u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
+  EXPECT_EQ(kStreamId, visitor_.stream_frames_[0]->stream_id);
   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
-  EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
+  EXPECT_EQ(kStreamOffset, visitor_.stream_frames_[0]->offset);
   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
 }
 
@@ -1712,10 +1709,10 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
+  EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.missing_packets.NumPacketsSlow());
   ASSERT_EQ(2u, frame.received_packet_times.size());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
+  EXPECT_EQ(kMissingPacket, frame.missing_packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
@@ -1828,10 +1825,10 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
+  EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.missing_packets.NumPacketsSlow());
   ASSERT_EQ(1u, frame.received_packet_times.size());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
+  EXPECT_EQ(kMissingPacket, frame.missing_packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset =
@@ -1930,9 +1927,9 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
+  EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.missing_packets.NumPacketsSlow());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
+  EXPECT_EQ(kMissingPacket, frame.missing_packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
@@ -2028,9 +2025,9 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame.entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
+  EXPECT_EQ(kLargestObserved, frame.largest_observed);
   ASSERT_EQ(1u, frame.missing_packets.NumPacketsSlow());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
+  EXPECT_EQ(kMissingPacket, frame.missing_packets.Min());
 
   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
@@ -2120,7 +2117,7 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   QuicAckFrame* frame = visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame->largest_observed);
+  EXPECT_EQ(kLargestObserved, frame->largest_observed);
   ASSERT_TRUE(frame->missing_packets.Empty());
 
   // Verify that the packet re-serializes identically.
@@ -2185,11 +2182,11 @@
   ASSERT_EQ(1u, visitor_.ack_frames_.size());
   QuicAckFrame* frame = visitor_.ack_frames_[0];
   EXPECT_EQ(0xBA, frame->entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789ABF), frame->largest_observed);
+  EXPECT_EQ(kLargestObserved, frame->largest_observed);
   EXPECT_EQ(0u, frame->latest_revived_packet);
   ASSERT_EQ(500u, frame->missing_packets.NumPacketsSlow());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE) - 499, frame->missing_packets.Min());
-  EXPECT_EQ(UINT64_C(0x0123456789ABE), frame->missing_packets.Max());
+  EXPECT_EQ(kMissingPacket - 499, frame->missing_packets.Min());
+  EXPECT_EQ(kMissingPacket, frame->missing_packets.Max());
 
   // Verify that the packet re-serializes identically.
   QuicFrames frames;
@@ -2238,7 +2235,7 @@
   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
   const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
   EXPECT_EQ(0xAB, frame.entropy_hash);
-  EXPECT_EQ(UINT64_C(0x0123456789AA0), frame.least_unacked);
+  EXPECT_EQ(kLeastUnacked, frame.least_unacked);
 
   const size_t kSentEntropyOffset = kQuicFrameTypeSize;
   const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
@@ -2278,8 +2275,8 @@
     0x04, 0x03, 0x02, 0x01,
 
     // sent byte offset
-    0x01, 0x02, 0x03, 0x04,
-    0x05, 0x06, 0x07, 0x08,
+    0x54, 0x76, 0x10, 0x32,
+    0xDC, 0xFE, 0x98, 0xBA,
 
     // error code
     0x01, 0x00, 0x00, 0x00,
@@ -2293,10 +2290,9 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id);
+  EXPECT_EQ(kStreamId, visitor_.rst_stream_frame_.stream_id);
   EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
-  EXPECT_EQ(UINT64_C(0x0807060504030201),
-            visitor_.rst_stream_frame_.byte_offset);
+  EXPECT_EQ(kStreamOffset, visitor_.rst_stream_frame_.byte_offset);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetRstStreamFrameSize();
@@ -2416,7 +2412,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.goaway_frame_.last_good_stream_id);
+  EXPECT_EQ(kStreamId, visitor_.goaway_frame_.last_good_stream_id);
   EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code);
   EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
 
@@ -2460,8 +2456,8 @@
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // byte offset
-    0x05, 0x06, 0x07, 0x08,
-    0x09, 0x0a, 0x0b, 0x0c,
+    0x54, 0x76, 0x10, 0x32,
+    0xDC, 0xFE, 0x98, 0xBA,
   };
   // clang-format on
 
@@ -2473,9 +2469,8 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.window_update_frame_.stream_id);
-  EXPECT_EQ(UINT64_C(0x0c0b0a0908070605),
-            visitor_.window_update_frame_.byte_offset);
+  EXPECT_EQ(kStreamId, visitor_.window_update_frame_.stream_id);
+  EXPECT_EQ(kStreamOffset, visitor_.window_update_frame_.byte_offset);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize;
@@ -2523,7 +2518,7 @@
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
-  EXPECT_EQ(UINT64_C(0x01020304), visitor_.blocked_frame_.stream_id);
+  EXPECT_EQ(kStreamId, visitor_.blocked_frame_.stream_id);
 
   // Now test framing boundaries.
   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize();
@@ -2601,13 +2596,12 @@
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
+  EXPECT_EQ(kConnectionId,
             visitor_.public_reset_packet_->public_header.connection_id);
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
-  EXPECT_EQ(UINT64_C(0xABCDEF0123456789),
-            visitor_.public_reset_packet_->nonce_proof);
-  EXPECT_EQ(UINT64_C(0x123456789ABC),
+  EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
+  EXPECT_EQ(kPacketNumber,
             visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_TRUE(
       visitor_.public_reset_packet_->client_address.address().empty());
@@ -2709,13 +2703,12 @@
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.public_reset_packet_.get());
-  EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
+  EXPECT_EQ(kConnectionId,
             visitor_.public_reset_packet_->public_header.connection_id);
   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
-  EXPECT_EQ(UINT64_C(0xABCDEF0123456789),
-            visitor_.public_reset_packet_->nonce_proof);
-  EXPECT_EQ(UINT64_C(0x123456789ABC),
+  EXPECT_EQ(kNonceProof, visitor_.public_reset_packet_->nonce_proof);
+  EXPECT_EQ(kPacketNumber,
             visitor_.public_reset_packet_->rejected_packet_number);
   EXPECT_EQ("4.31.198.44",
             IPAddressToString(visitor_.public_reset_packet_->
@@ -2819,12 +2812,12 @@
 
 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicPaddingFrame padding_frame;
@@ -2867,13 +2860,13 @@
 
 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicPaddingFrame padding_frame;
@@ -2915,13 +2908,13 @@
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicPaddingFrame padding_frame;
@@ -2963,13 +2956,13 @@
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicPaddingFrame padding_frame;
@@ -3011,15 +3004,15 @@
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x77123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
-  QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
+  QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
@@ -3062,16 +3055,16 @@
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketInFecGroup) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x77123456789ABC);
+  header.packet_number = kPacketNumber;
   header.is_in_fec_group = IN_FEC_GROUP;
-  header.fec_group = UINT64_C(0x77123456789ABC);
+  header.fec_group = kPacketNumber;
 
-  QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
+  QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
@@ -3111,15 +3104,15 @@
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = true;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x77123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
-  QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
+  QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
@@ -3195,11 +3188,6 @@
 }
 
 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
-  QuicPacketPublicHeader header;
-  header.connection_id = UINT64_C(0xFEDCBA9876543210);
-  header.reset_flag = false;
-  header.version_flag = true;
-
   // clang-format off
   unsigned char packet[] = {
       // public flags (version, 8 byte connection_id)
@@ -3221,11 +3209,9 @@
   };
   // clang-format on
 
-  QuicVersionVector versions;
-  versions.push_back(GetParam());
-  scoped_ptr<QuicEncryptedPacket> data(
-      framer_.BuildVersionNegotiationPacket(header, versions));
-
+  QuicConnectionId connection_id = kConnectionId;
+  scoped_ptr<QuicEncryptedPacket> data(framer_.BuildVersionNegotiationPacket(
+      connection_id, SupportedVersions(GetParam())));
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(packet),
                                       arraysize(packet));
@@ -3233,19 +3219,19 @@
 
 TEST_P(QuicFramerTest, BuildAckFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x770123456789AA8);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
   ack_frame.entropy_hash = 0x43;
-  ack_frame.largest_observed = UINT64_C(0x770123456789ABF);
+  ack_frame.largest_observed = kLargestObserved;
   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
-  ack_frame.missing_packets.Add(UINT64_C(0x770123456789ABE));
+  ack_frame.missing_packets.Add(kMissingPacket);
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&ack_frame));
@@ -3257,7 +3243,7 @@
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
+      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
@@ -3296,12 +3282,12 @@
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x770123456789AA8);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
@@ -3325,7 +3311,7 @@
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
+      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
@@ -3407,12 +3393,12 @@
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x770123456789AA8);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
@@ -3436,7 +3422,7 @@
       // connection_id
       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
       // packet number
-      0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
+      0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
       // private flags (entropy)
       0x01,
 
@@ -3472,17 +3458,17 @@
 
 TEST_P(QuicFramerTest, BuildStopWaitingPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x770123456789AA8);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicStopWaitingFrame stop_waiting_frame;
   stop_waiting_frame.entropy_hash = 0x14;
-  stop_waiting_frame.least_unacked = UINT64_C(0x770123456789AA0);
+  stop_waiting_frame.least_unacked = kLeastUnacked;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stop_waiting_frame));
@@ -3495,8 +3481,7 @@
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet number
-    0xA8, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
+    0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
     // private flags (entropy)
     0x01,
 
@@ -3505,7 +3490,7 @@
     // entropy hash of sent packets till least awaiting - 1.
     0x14,
     // least packet number awaiting an ack, delta from packet number.
-    0x08, 0x00, 0x00, 0x00,
+    0x1C, 0x00, 0x00, 0x00,
     0x00, 0x00,
   };
   // clang-format on
@@ -3520,16 +3505,16 @@
 
 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicRstStreamFrame rst_frame;
-  rst_frame.stream_id = 0x01020304;
+  rst_frame.stream_id = kStreamId;
   rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
   rst_frame.byte_offset = 0x0807060504030201;
 
@@ -3571,12 +3556,12 @@
 
 TEST_P(QuicFramerTest, BuildCloseFramePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicConnectionCloseFrame close_frame;
@@ -3623,17 +3608,17 @@
 
 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicGoAwayFrame goaway_frame;
   goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
-  goaway_frame.last_good_stream_id = 0x01020304;
+  goaway_frame.last_good_stream_id = kStreamId;
   goaway_frame.reason_phrase = "because I can";
 
   QuicFrames frames;
@@ -3678,16 +3663,16 @@
 
 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicWindowUpdateFrame window_update_frame;
-  window_update_frame.stream_id = 0x01020304;
+  window_update_frame.stream_id = kStreamId;
   window_update_frame.byte_offset = 0x1122334455667788;
 
   QuicFrames frames;
@@ -3726,16 +3711,16 @@
 
 TEST_P(QuicFramerTest, BuildBlockedPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicBlockedFrame blocked_frame;
-  blocked_frame.stream_id = 0x01020304;
+  blocked_frame.stream_id = kStreamId;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&blocked_frame));
@@ -3770,12 +3755,12 @@
 
 TEST_P(QuicFramerTest, BuildPingPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicPingFrame ping_frame;
@@ -3812,12 +3797,12 @@
 // Test that the MTU discovery packet is serialized correctly as a PING packet.
 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicMtuDiscoveryFrame mtu_discovery_frame;
@@ -3853,11 +3838,11 @@
 
 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
   QuicPublicResetPacket reset_packet;
-  reset_packet.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  reset_packet.public_header.connection_id = kConnectionId;
   reset_packet.public_header.reset_flag = true;
   reset_packet.public_header.version_flag = false;
-  reset_packet.rejected_packet_number = UINT64_C(0x123456789ABC);
-  reset_packet.nonce_proof = UINT64_C(0xABCDEF0123456789);
+  reset_packet.rejected_packet_number = kPacketNumber;
+  reset_packet.nonce_proof = kNonceProof;
 
   // clang-format off
   unsigned char packet[] = {
@@ -3898,11 +3883,11 @@
 
 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
   QuicPublicResetPacket reset_packet;
-  reset_packet.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  reset_packet.public_header.connection_id = kConnectionId;
   reset_packet.public_header.reset_flag = true;
   reset_packet.public_header.version_flag = false;
-  reset_packet.rejected_packet_number = UINT64_C(0x123456789ABC);
-  reset_packet.nonce_proof = UINT64_C(0xABCDEF0123456789);
+  reset_packet.rejected_packet_number = kPacketNumber;
+  reset_packet.nonce_proof = kNonceProof;
   reset_packet.client_address = IPEndPoint(Loopback4(), 0x1234);
 
   // clang-format off
@@ -3952,14 +3937,14 @@
 
 TEST_P(QuicFramerTest, BuildFecPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = true;
   header.entropy_flag = true;
-  header.packet_number = (UINT64_C(0x123456789ABC));
+  header.packet_number = kPacketNumber;
   header.is_in_fec_group = IN_FEC_GROUP;
-  header.fec_group = UINT64_C(0x123456789ABB);
+  header.fec_group = kPacketNumber - 1;
 
   string redundancy = "abcdefghijklmnop";
 
@@ -3995,7 +3980,7 @@
 }
 
 TEST_P(QuicFramerTest, EncryptPacket) {
-  QuicPacketNumber packet_number = UINT64_C(0x123456789ABC);
+  QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
@@ -4031,7 +4016,7 @@
 }
 
 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {
-  QuicPacketNumber packet_number = UINT64_C(0x123456789ABC);
+  QuicPacketNumber packet_number = kPacketNumber;
   // clang-format off
   unsigned char packet[] = {
     // public flags (version, 8 byte connection_id)
@@ -4070,12 +4055,12 @@
 
 TEST_P(QuicFramerTest, AckTruncationLargePacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   // Create a packet with just the ack.
@@ -4108,12 +4093,12 @@
 
 TEST_P(QuicFramerTest, AckTruncationSmallPacket) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = false;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   // Create a packet with just the ack.
@@ -4146,12 +4131,12 @@
 
 TEST_P(QuicFramerTest, CleanTruncation) {
   QuicPacketHeader header;
-  header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
+  header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
   header.fec_flag = false;
   header.entropy_flag = true;
-  header.packet_number = UINT64_C(0x123456789ABC);
+  header.packet_number = kPacketNumber;
   header.fec_group = 0;
 
   QuicAckFrame ack_frame;
diff --git a/net/quic/quic_headers_stream_test.cc b/net/quic/quic_headers_stream_test.cc
index b5ca189..95c923df 100644
--- a/net/quic/quic_headers_stream_test.cc
+++ b/net/quic/quic_headers_stream_test.cc
@@ -10,6 +10,7 @@
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
+#include "net/spdy/spdy_alt_svc_wire_format.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
diff --git a/net/quic/quic_multipath_transmissions_map.cc b/net/quic/quic_multipath_transmissions_map.cc
new file mode 100644
index 0000000..14655e37
--- /dev/null
+++ b/net/quic/quic_multipath_transmissions_map.cc
@@ -0,0 +1,70 @@
+// Copyright (c) 2015 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_multipath_transmissions_map.h"
+
+namespace net_quic {
+
+QuicMultipathTransmissionsMap::QuicMultipathTransmissionsMap() {}
+
+QuicMultipathTransmissionsMap::~QuicMultipathTransmissionsMap() {
+  for (std::pair<QuicPathIdPacketNumber, MultipathTransmissionsList*>
+           packet_transmissions : transmission_map_) {
+    packet_transmissions.second->pop_front();
+    if (packet_transmissions.second->empty()) {
+      delete packet_transmissions.second;
+    }
+  }
+}
+
+void QuicMultipathTransmissionsMap::OnPacketRetransmittedOnDifferentPath(
+    QuicPathIdPacketNumber original_path_id_packet_number,
+    QuicPathIdPacketNumber path_id_packet_number) {
+  MultipathTransmissionsList* across_paths_transmission_list = nullptr;
+  MultipathTransmissionsMap::iterator it =
+      transmission_map_.find(original_path_id_packet_number);
+  if (it != transmission_map_.end()) {
+    across_paths_transmission_list = it->second;
+  } else {
+    across_paths_transmission_list = new MultipathTransmissionsList();
+    across_paths_transmission_list->push_back(original_path_id_packet_number);
+    transmission_map_[original_path_id_packet_number] =
+        across_paths_transmission_list;
+  }
+
+  across_paths_transmission_list->push_back(path_id_packet_number);
+  transmission_map_[path_id_packet_number] = across_paths_transmission_list;
+}
+
+const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+QuicMultipathTransmissionsMap::MaybeGetTransmissionsOnOtherPaths(
+    QuicPathIdPacketNumber path_id_packet_number) const {
+  MultipathTransmissionsMap::const_iterator it =
+      transmission_map_.find(path_id_packet_number);
+  if (it == transmission_map_.end()) {
+    return nullptr;
+  }
+
+  return it->second;
+}
+
+void QuicMultipathTransmissionsMap::OnPacketHandled(
+    QuicPathIdPacketNumber path_id_packet_number) {
+  MultipathTransmissionsMap::iterator it =
+      transmission_map_.find(path_id_packet_number);
+  if (it == transmission_map_.end()) {
+    return;
+  }
+
+  MultipathTransmissionsList* transmission_list = it->second;
+  MultipathTransmissionsList::iterator transmission_it;
+  // Remove all across paths transmissions of this packet from the map.
+  for (QuicPathIdPacketNumber path_id_packet_number : *transmission_list) {
+    transmission_map_.erase(path_id_packet_number);
+  }
+  // Remove the multipath transmissions list.
+  delete transmission_list;
+}
+
+}  // namespace net_quic
diff --git a/net/quic/quic_multipath_transmissions_map.h b/net/quic/quic_multipath_transmissions_map.h
new file mode 100644
index 0000000..121e63e
--- /dev/null
+++ b/net/quic/quic_multipath_transmissions_map.h
@@ -0,0 +1,65 @@
+// Copyright (c) 2015 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.
+
+// A map manages packets which are transmitted across multiple paths.
+// For example, a packet is originally transmitted on path 1 with packet number
+// 1. Then this packet is retransmitted on path 2 with packet number 1. (1, 1)
+// and (2, 1) are inserted into this map. Suppose (2, 1) is detected lost and
+// gets retransmitted on path 2 with packet 2. (2, 2) will not be inserted
+// because this transmission does not "across" path compared to (2, 1).
+
+#ifndef NET_QUIC_QUIC_MULTIPATH_TRANSMISSIONS_MAP_H_
+#define NET_QUIC_QUIC_MULTIPATH_TRANSMISSIONS_MAP_H_
+
+#include <deque>
+
+#include "base/containers/hash_tables.h"
+#include "base/macros.h"
+#include "net/quic/quic_protocol.h"
+
+namespace net_quic {
+
+typedef std::pair<net::QuicPathId, net::QuicPacketNumber>
+    QuicPathIdPacketNumber;
+
+class NET_EXPORT_PRIVATE QuicMultipathTransmissionsMap {
+ public:
+  typedef std::deque<QuicPathIdPacketNumber> MultipathTransmissionsList;
+  typedef base::hash_map<QuicPathIdPacketNumber, MultipathTransmissionsList*>
+      MultipathTransmissionsMap;
+
+  QuicMultipathTransmissionsMap();
+  ~QuicMultipathTransmissionsMap();
+
+  // Called when a packet is retransmitted on a different path. Adds both
+  // |original_path_id_packet_number| (if not exists) and
+  // |path_id_packet_number| to |transmission_map_|.
+  void OnPacketRetransmittedOnDifferentPath(
+      QuicPathIdPacketNumber original_path_id_packet_number,
+      QuicPathIdPacketNumber path_id_packet_number);
+
+  // Returns all multipath transmissions list if |path_id_packet_number| has
+  // been transmitted across multiple paths, nullptr otherwise.
+  const MultipathTransmissionsList* MaybeGetTransmissionsOnOtherPaths(
+      QuicPathIdPacketNumber path_id_packet_number) const;
+
+  // Called after packet |path_id_packet_number| is received.
+  // If |path_id_packet_number| has been transmitted across multiple paths,
+  // clears all multipath transmissions list and removes each transmission from
+  // |transmission_map_|, does nothing otherwise.
+  void OnPacketHandled(QuicPathIdPacketNumber path_id_packet_number);
+
+ private:
+  // Keys of the map are QuicPathIdPacketNumber, and values are pointers to
+  // lists of multipath transmissions of the same packet. For example, if a
+  // packet has been transmitted as (1, 1) and (2, 1), two entries are added
+  // to this map and both values point to the same list: {(1, 1), (2, 1)}.
+  // The MultipathTransmissionsList is owned by the transmission which is
+  // received first (on any path).
+  MultipathTransmissionsMap transmission_map_;
+};
+
+}  // namespace net_quic
+
+#endif  // NET_QUIC_QUIC_MULTIPATH_TRANSMISSIONS_MAP_H_
diff --git a/net/quic/quic_multipath_transmissions_map_test.cc b/net/quic/quic_multipath_transmissions_map_test.cc
new file mode 100644
index 0000000..fcae200
--- /dev/null
+++ b/net/quic/quic_multipath_transmissions_map_test.cc
@@ -0,0 +1,114 @@
+// Copyright (c) 2015 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_multipath_transmissions_map.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net_quic {
+namespace test {
+namespace {
+
+TEST(QuicAcrossPathsTransmissionMapTest, OnPacketRetransmittedOnDifferentPath) {
+  QuicMultipathTransmissionsMap transmission_map;
+  // Packet0's original transmission sent on path 1 with packet number 1.
+  QuicPathIdPacketNumber packet0_0(1, 1);
+  // Packet0's retransmission sent on path 2 with packet number 1.
+  QuicPathIdPacketNumber packet0_1(2, 1);
+  // packet0's 2nd retransmission sent on path 3 with packet number 1.
+  QuicPathIdPacketNumber packet0_2(3, 1);
+
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_0, packet0_1);
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list1 =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_0);
+  EXPECT_EQ(packet0_0, (*transmission_list1)[0]);
+  EXPECT_EQ(packet0_1, (*transmission_list1)[1]);
+
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_1, packet0_2);
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list2 =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_0);
+  EXPECT_EQ(packet0_0, (*transmission_list2)[0]);
+  EXPECT_EQ(packet0_1, (*transmission_list2)[1]);
+  EXPECT_EQ(packet0_2, (*transmission_list2)[2]);
+  // Make sure there is no memory leakage.
+}
+
+TEST(QuicAcrossPathsTransmissionMapTest, MaybeGetTransmissionsOnOtherPaths) {
+  QuicMultipathTransmissionsMap transmission_map;
+  // Packet0's original transmission sent on path 1 with packet number 1.
+  QuicPathIdPacketNumber packet0_0(1, 1);
+  // Packet0's retransmission sent on path 2 with packet number 1.
+  QuicPathIdPacketNumber packet0_1(2, 1);
+  // packet0's 2nd retransmission sent on path 3 with packet number 1.
+  QuicPathIdPacketNumber packet0_2(3, 1);
+
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_0, packet0_1);
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_1, packet0_2);
+
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list1 =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_0);
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list2 =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_1);
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list3 =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_2);
+  // Make sure all three pointers point to the same list.
+  EXPECT_EQ(transmission_list1, transmission_list2);
+  EXPECT_EQ(transmission_list2, transmission_list3);
+  EXPECT_EQ(packet0_0, (*transmission_list1)[0]);
+  EXPECT_EQ(packet0_1, (*transmission_list1)[1]);
+  EXPECT_EQ(packet0_2, (*transmission_list1)[2]);
+
+  // Packet1 which is not transmitted across path.
+  QuicPathIdPacketNumber packet1_0(1, 2);
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet1_0));
+  // Make sure there is no memory leakage.
+}
+
+TEST(QuicAcrossPathsTransmissionMapTest, OnPacketHandled) {
+  QuicMultipathTransmissionsMap transmission_map;
+
+  // Packet's original transmission sent on path 1 with packet number 1.
+  QuicPathIdPacketNumber packet0_0(1, 1);
+  // Packet's retransmission sent on path 2 with packet number 1.
+  QuicPathIdPacketNumber packet0_1(2, 1);
+  // packet's 2nd retransmission sent on path 3 with packet number 1.
+  QuicPathIdPacketNumber packet0_2(3, 1);
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_0, packet0_1);
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet0_1, packet0_2);
+
+  // Packet1's original transmission sent on path 1 with packet number 2.
+  QuicPathIdPacketNumber packet1_0(1, 2);
+  // Packet1's retransmission sent on path 2 with packet number 2.
+  QuicPathIdPacketNumber packet1_1(2, 2);
+  transmission_map.OnPacketRetransmittedOnDifferentPath(packet1_0, packet1_1);
+
+  transmission_map.OnPacketHandled(packet0_0);
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_0));
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_1));
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet0_2));
+  const QuicMultipathTransmissionsMap::MultipathTransmissionsList*
+      transmission_list =
+          transmission_map.MaybeGetTransmissionsOnOtherPaths(packet1_0);
+  EXPECT_EQ(packet1_0, (*transmission_list)[0]);
+  EXPECT_EQ(packet1_1, (*transmission_list)[1]);
+  // Packet 1 is received on path 2.
+  transmission_map.OnPacketHandled(packet1_1);
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet1_0));
+  EXPECT_EQ(nullptr,
+            transmission_map.MaybeGetTransmissionsOnOtherPaths(packet1_1));
+  // Make sure there is no memory leakage.
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace net_quic
diff --git a/net/quic/quic_packet_creator.cc b/net/quic/quic_packet_creator.cc
index ccbf7e9..c2a400b 100644
--- a/net/quic/quic_packet_creator.cc
+++ b/net/quic/quic_packet_creator.cc
@@ -599,13 +599,8 @@
 QuicEncryptedPacket* QuicPacketCreator::SerializeVersionNegotiationPacket(
     const QuicVersionVector& supported_versions) {
   DCHECK_EQ(Perspective::IS_SERVER, framer_->perspective());
-  QuicPacketPublicHeader header;
-  header.connection_id = connection_id_;
-  header.reset_flag = false;
-  header.version_flag = true;
-  header.versions = supported_versions;
-  QuicEncryptedPacket* encrypted =
-      framer_->BuildVersionNegotiationPacket(header, supported_versions);
+  QuicEncryptedPacket* encrypted = QuicFramer::BuildVersionNegotiationPacket(
+      connection_id_, supported_versions);
   DCHECK(encrypted);
   DCHECK_GE(max_packet_length_, encrypted->length());
   return encrypted;
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 1286b9a..fe4e8b7 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -41,6 +41,7 @@
 typedef uint32 QuicStreamId;
 typedef uint64 QuicStreamOffset;
 typedef uint64 QuicPacketNumber;
+typedef uint8 QuicPathId;
 typedef QuicPacketNumber QuicFecGroupNumber;
 typedef uint64 QuicPublicResetNonceProof;
 typedef uint8 QuicPacketEntropyHash;
@@ -73,6 +74,10 @@
 // Minimum size of initial flow control window, for both stream and session.
 const uint32 kMinimumFlowControlSendWindow = 16 * 1024;  // 16 KB
 
+// Maximum flow control receive window limits for connection and stream.
+const QuicByteCount kStreamReceiveWindowLimit = 16 * 1024 * 1024;   // 16 MB
+const QuicByteCount kSessionReceiveWindowLimit = 24 * 1024 * 1024;  // 24 MB
+
 // Minimum size of the CWND, in packets, when doing bandwidth resumption.
 const QuicPacketCount kMinCongestionWindowForBandwidthResumption = 10;
 
diff --git a/net/quic/quic_sent_packet_manager.cc b/net/quic/quic_sent_packet_manager.cc
index 586d27a..20d357a 100644
--- a/net/quic/quic_sent_packet_manager.cc
+++ b/net/quic/quic_sent_packet_manager.cc
@@ -935,4 +935,19 @@
                        kInitialUnpacedBurst));
 }
 
+void QuicSentPacketManager::OnConnectionMigration(PeerAddressChangeType type) {
+  if (type == UNKNOWN) {
+    return;
+  }
+
+  if (type == NAT_PORT_REBINDING || type == IPV4_SUBNET_REBINDING) {
+    // Rtt and cwnd do not need to be reset when the peer address change is
+    // considered to be caused by NATs.
+    return;
+  }
+
+  rtt_stats_.OnConnectionMigration();
+  send_algorithm_->OnConnectionMigration();
+}
+
 }  // namespace net
diff --git a/net/quic/quic_sent_packet_manager.h b/net/quic/quic_sent_packet_manager.h
index c37d3c3..73c695b 100644
--- a/net/quic/quic_sent_packet_manager.h
+++ b/net/quic/quic_sent_packet_manager.h
@@ -213,6 +213,9 @@
   // Enables pacing if it has not already been enabled.
   void EnablePacing();
 
+  // Called when peer address changes and the connection migrates.
+  void OnConnectionMigration(PeerAddressChangeType type);
+
   bool using_pacing() const { return using_pacing_; }
 
   void set_debug_delegate(DebugDelegate* debug_delegate) {
diff --git a/net/quic/quic_spdy_stream.cc b/net/quic/quic_spdy_stream.cc
index 746e96a8..775348f 100644
--- a/net/quic/quic_spdy_stream.cc
+++ b/net/quic/quic_spdy_stream.cc
@@ -14,6 +14,10 @@
 
 namespace net {
 
+#define ENDPOINT                                                               \
+  (session()->perspective() == Perspective::IS_SERVER ? "Server: " : "Client:" \
+                                                                     " ")
+
 namespace {
 
 // This is somewhat arbitrary.  It's possible, but unlikely, we will either fail
@@ -38,6 +42,29 @@
 
 QuicSpdyStream::~QuicSpdyStream() {}
 
+void QuicSpdyStream::CloseWriteSide() {
+  if (version() > QUIC_VERSION_28 && !fin_received() && !rst_received() &&
+      sequencer()->ignore_read_data() && !rst_sent()) {
+    DCHECK(fin_sent());
+    // Tell the peer to stop sending further data.
+    DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
+    Reset(QUIC_STREAM_NO_ERROR);
+  }
+
+  ReliableQuicStream::CloseWriteSide();
+}
+
+void QuicSpdyStream::StopReading() {
+  if (version() > QUIC_VERSION_28 && !fin_received() && !rst_received() &&
+      write_side_closed() && !rst_sent()) {
+    DCHECK(fin_sent());
+    // Tell the peer to stop sending further data.
+    DVLOG(1) << ENDPOINT << "Send QUIC_STREAM_NO_ERROR on stream " << id();
+    Reset(QUIC_STREAM_NO_ERROR);
+  }
+  ReliableQuicStream::StopReading();
+}
+
 size_t QuicSpdyStream::WriteHeaders(
     const SpdyHeaderBlock& header_block,
     bool fin,
diff --git a/net/quic/quic_spdy_stream.h b/net/quic/quic_spdy_stream.h
index 48e74b1..543e490 100644
--- a/net/quic/quic_spdy_stream.h
+++ b/net/quic/quic_spdy_stream.h
@@ -54,6 +54,11 @@
   QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session);
   ~QuicSpdyStream() override;
 
+  // Override the base class to send QUIC_STREAM_NO_ERROR to the peer
+  // when the stream has not received all the data.
+  void CloseWriteSide() override;
+  void StopReading() override;
+
   // ReliableQuicStream implementation
   void OnClose() override;
 
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index f4467559..2012c95 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -1371,7 +1371,7 @@
 
   cached->Initialize(server_info->state().server_config,
                      server_info->state().source_address_token,
-                     server_info->state().certs,
+                     server_info->state().certs, "",
                      server_info->state().server_config_sig, clock_->WallNow());
 }
 
diff --git a/net/quic/quic_stream_sequencer.cc b/net/quic/quic_stream_sequencer.cc
index 12fe8c7..b3f17dd 100644
--- a/net/quic/quic_stream_sequencer.cc
+++ b/net/quic/quic_stream_sequencer.cc
@@ -12,7 +12,9 @@
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_frame_list.h"
+#include "net/quic/quic_protocol.h"
 #include "net/quic/reliable_quic_stream.h"
+#include "net/quic/stream_sequencer_buffer.h"
 
 using std::min;
 using std::numeric_limits;
@@ -23,14 +25,21 @@
 QuicStreamSequencer::QuicStreamSequencer(ReliableQuicStream* quic_stream,
                                          const QuicClock* clock)
     : stream_(quic_stream),
-      buffered_frames_(new QuicFrameList()),
       close_offset_(numeric_limits<QuicStreamOffset>::max()),
       blocked_(false),
       num_frames_received_(0),
       num_duplicate_frames_received_(0),
       num_early_frames_received_(0),
       clock_(clock),
-      ignore_read_data_(false) {}
+      ignore_read_data_(false) {
+  if (FLAGS_quic_use_stream_sequencer_buffer) {
+    DVLOG(1) << "Use StreamSequencerBuffer for stream: " << stream_->id();
+    buffered_frames_.reset(
+        new StreamSequencerBuffer(kStreamReceiveWindowLimit));
+  } else {
+    buffered_frames_.reset(new QuicFrameList());
+  }
+}
 
 QuicStreamSequencer::~QuicStreamSequencer() {}
 
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index aaf1d26..7a16115 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -10,6 +10,7 @@
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/base/ip_endpoint.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_frame_list.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/reliable_quic_stream.h"
@@ -59,8 +60,13 @@
 static const char kPayload[] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 
-class QuicStreamSequencerTest : public ::testing::Test {
+class QuicStreamSequencerTest : public ::testing::TestWithParam<bool> {
  public:
+  void SetUp() override {
+    FLAGS_quic_use_stream_sequencer_buffer = GetParam();
+    sequencer_.reset(new QuicStreamSequencer(&stream_, &clock_));
+  }
+
   void ConsumeData(size_t num_bytes) {
     char buffer[1024];
     ASSERT_GT(arraysize(buffer), num_bytes);
@@ -74,39 +80,51 @@
   QuicStreamSequencerTest()
       : connection_(new MockConnection(&helper_, Perspective::IS_CLIENT)),
         session_(connection_),
-        stream_(&session_, 1),
-        sequencer_(new QuicStreamSequencer(&stream_, &clock_)) {}
+        stream_(&session_, 1) {}
 
-  bool VerifyReadableRegion(const char** expected) {
+  // Verify that the data in first region match with the expected[0].
+  bool VerifyReadableRegion(const vector<string>& expected) {
     iovec iovecs[1];
-    QuicTime timestamp = clock_.ApproximateNow();
-    if (sequencer_->GetReadableRegion(iovecs, &timestamp)) {
-      return (VerifyIovecs(iovecs, 1, expected, 1));
+    if (sequencer_->GetReadableRegions(iovecs, 1)) {
+      return (VerifyIovecs(iovecs, 1, vector<string>{expected[0]}));
     }
     return false;
   }
 
-  bool VerifyReadableRegions(const char** expected, size_t num_expected) {
+  // Verify that the data in each of currently readable regions match with each
+  // item given in |expected|.
+  bool VerifyReadableRegions(const vector<string>& expected) {
     iovec iovecs[5];
     size_t num_iovecs =
         sequencer_->GetReadableRegions(iovecs, arraysize(iovecs));
     return VerifyReadableRegion(expected) &&
-           VerifyIovecs(iovecs, num_iovecs, expected, num_expected);
+           VerifyIovecs(iovecs, num_iovecs, expected);
   }
 
   bool VerifyIovecs(iovec* iovecs,
                     size_t num_iovecs,
-                    const char** expected,
-                    size_t num_expected) {
-    if (num_expected != num_iovecs) {
-      LOG(ERROR) << "Incorrect number of iovecs.  Expected: " << num_expected
-                 << " Actual: " << num_iovecs;
-      return false;
-    }
-    for (size_t i = 0; i < num_expected; ++i) {
-      if (!VerifyIovec(iovecs[i], expected[i])) {
+                    const vector<string>& expected) {
+    if (!FLAGS_quic_use_stream_sequencer_buffer) {
+      if (expected.size() != num_iovecs) {
+        LOG(ERROR) << "Incorrect number of iovecs.  Expected: "
+                   << expected.size() << " Actual: " << num_iovecs;
         return false;
       }
+
+      for (size_t i = 0; i < num_iovecs; ++i) {
+        if (!VerifyIovec(iovecs[i], expected[i])) {
+          return false;
+        }
+      }
+    } else {
+      int start_position = 0;
+      for (size_t i = 0; i < num_iovecs; ++i) {
+        if (!VerifyIovec(iovecs[i], expected[0].substr(start_position,
+                                                       iovecs[i].iov_len))) {
+          return false;
+        }
+        start_position += iovecs[i].iov_len;
+      }
     }
     return true;
   }
@@ -155,9 +173,13 @@
   scoped_ptr<QuicStreamSequencer> sequencer_;
 };
 
+INSTANTIATE_TEST_CASE_P(QuicStreamSequencerTests,
+                        QuicStreamSequencerTest,
+                        ::testing::Values(false, true));
+
 // TODO(rch): reorder these tests so they build on each other.
 
-TEST_F(QuicStreamSequencerTest, RejectOldFrame) {
+TEST_P(QuicStreamSequencerTest, RejectOldFrame) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
@@ -173,7 +195,7 @@
   EXPECT_EQ(0u, NumBufferedBytes());
 }
 
-TEST_F(QuicStreamSequencerTest, RejectBufferedFrame) {
+TEST_P(QuicStreamSequencerTest, RejectBufferedFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
@@ -186,7 +208,7 @@
   EXPECT_EQ(3u, NumBufferedBytes());
 }
 
-TEST_F(QuicStreamSequencerTest, FullFrameConsumed) {
+TEST_P(QuicStreamSequencerTest, FullFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 3)));
@@ -196,7 +218,7 @@
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
-TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
+TEST_P(QuicStreamSequencerTest, BlockedThenFullFrameConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFrame(0, "abc");
@@ -218,7 +240,7 @@
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
-TEST_F(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
+TEST_P(QuicStreamSequencerTest, BlockedThenFullFrameAndFinConsumed) {
   sequencer_->SetBlockedUntilFlush();
 
   OnFinFrame(0, "abc");
@@ -235,7 +257,7 @@
   EXPECT_EQ(3u, sequencer_->NumBytesConsumed());
 }
 
-TEST_F(QuicStreamSequencerTest, EmptyFrame) {
+TEST_P(QuicStreamSequencerTest, EmptyFrame) {
   EXPECT_CALL(stream_,
               CloseConnectionWithDetails(QUIC_INVALID_STREAM_FRAME, _));
   OnFrame(0, "");
@@ -243,14 +265,14 @@
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
-TEST_F(QuicStreamSequencerTest, EmptyFinFrame) {
+TEST_P(QuicStreamSequencerTest, EmptyFinFrame) {
   EXPECT_CALL(stream_, OnDataAvailable());
   OnFinFrame(0, "");
   EXPECT_EQ(0u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
 }
 
-TEST_F(QuicStreamSequencerTest, PartialFrameConsumed) {
+TEST_P(QuicStreamSequencerTest, PartialFrameConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable())
       .WillOnce(testing::Invoke(
           CreateFunctor(this, &QuicStreamSequencerTest::ConsumeData, 2)));
@@ -260,7 +282,7 @@
   EXPECT_EQ(2u, sequencer_->NumBytesConsumed());
 }
 
-TEST_F(QuicStreamSequencerTest, NextxFrameNotConsumed) {
+TEST_P(QuicStreamSequencerTest, NextxFrameNotConsumed) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
@@ -269,14 +291,14 @@
   EXPECT_EQ(0, sequencer_->num_early_frames_received());
 }
 
-TEST_F(QuicStreamSequencerTest, FutureFrameNotProcessed) {
+TEST_P(QuicStreamSequencerTest, FutureFrameNotProcessed) {
   OnFrame(3, "abc");
   EXPECT_EQ(3u, NumBufferedBytes());
   EXPECT_EQ(0u, sequencer_->NumBytesConsumed());
   EXPECT_EQ(1, sequencer_->num_early_frames_received());
 }
 
-TEST_F(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
+TEST_P(QuicStreamSequencerTest, OutOfOrderFrameProcessed) {
   // Buffer the first
   OnFrame(6, "ghi");
   EXPECT_EQ(3u, NumBufferedBytes());
@@ -300,7 +322,7 @@
   EXPECT_EQ(0u, NumBufferedBytes());
 }
 
-TEST_F(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
+TEST_P(QuicStreamSequencerTest, BasicHalfCloseOrdered) {
   InSequence s;
 
   EXPECT_CALL(stream_, OnDataAvailable())
@@ -311,7 +333,7 @@
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 }
 
-TEST_F(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) {
+TEST_P(QuicStreamSequencerTest, BasicHalfCloseUnorderedWithFlush) {
   OnFinFrame(6, "");
   EXPECT_EQ(6u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
@@ -324,7 +346,7 @@
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
-TEST_F(QuicStreamSequencerTest, BasicHalfUnordered) {
+TEST_P(QuicStreamSequencerTest, BasicHalfUnordered) {
   OnFinFrame(3, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
@@ -336,7 +358,7 @@
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
-TEST_F(QuicStreamSequencerTest, TerminateWithReadv) {
+TEST_P(QuicStreamSequencerTest, TerminateWithReadv) {
   char buffer[3];
 
   OnFinFrame(3, "");
@@ -353,7 +375,7 @@
   EXPECT_TRUE(sequencer_->IsClosed());
 }
 
-TEST_F(QuicStreamSequencerTest, MutipleOffsets) {
+TEST_P(QuicStreamSequencerTest, MutipleOffsets) {
   OnFinFrame(3, "");
   EXPECT_EQ(3u, QuicStreamSequencerPeer::GetCloseOffset(sequencer_.get()));
 
@@ -410,7 +432,7 @@
 
 // All frames are processed as soon as we have sequential data.
 // Infinite buffering, so all frames are acked right away.
-TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
+TEST_P(QuicSequencerRandomTest, RandomFramesNoDroppingNoBackup) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable())
       .Times(AnyNumber())
@@ -429,7 +451,7 @@
   EXPECT_EQ(kPayload, output_);
 }
 
-TEST_F(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
+TEST_P(QuicSequencerRandomTest, RandomFramesNoDroppingBackup) {
   char buffer[10];
   iovec iov[2];
   iov[0].iov_base = &buffer[0];
@@ -475,7 +497,7 @@
 }
 
 // Same as above, just using a different method for reading.
-TEST_F(QuicStreamSequencerTest, MarkConsumed) {
+TEST_P(QuicStreamSequencerTest, MarkConsumed) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable());
 
@@ -487,35 +509,50 @@
   EXPECT_EQ(9u, sequencer_->NumBytesBuffered());
 
   // Peek into the data.
-  const char* expected[] = {"abc", "def", "ghi"};
-  ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
+  vector<string> expected;
+  if (FLAGS_quic_use_stream_sequencer_buffer) {
+    expected = vector<string>{"abcdefghi"};
+  } else {
+    expected = vector<string>{"abc", "def", "ghi"};
+  }
+  ASSERT_TRUE(VerifyReadableRegions(expected));
 
   // Consume 1 byte.
   sequencer_->MarkConsumed(1);
   EXPECT_EQ(1u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  const char* expected2[] = {"bc", "def", "ghi"};
-  ASSERT_TRUE(VerifyReadableRegions(expected2, arraysize(expected2)));
+  vector<string> expected2;
+  if (FLAGS_quic_use_stream_sequencer_buffer) {
+    expected2 = vector<string>{"bcdefghi"};
+  } else {
+    expected2 = vector<string>{"bc", "def", "ghi"};
+  }
+  ASSERT_TRUE(VerifyReadableRegions(expected2));
   EXPECT_EQ(8u, sequencer_->NumBytesBuffered());
 
   // Consume 2 bytes.
   sequencer_->MarkConsumed(2);
   EXPECT_EQ(3u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  const char* expected3[] = {"def", "ghi"};
-  ASSERT_TRUE(VerifyReadableRegions(expected3, arraysize(expected3)));
+  vector<string> expected3;
+  if (FLAGS_quic_use_stream_sequencer_buffer) {
+    expected3 = vector<string>{"defghi"};
+  } else {
+    expected3 = vector<string>{"def", "ghi"};
+  }
+  ASSERT_TRUE(VerifyReadableRegions(expected3));
   EXPECT_EQ(6u, sequencer_->NumBytesBuffered());
 
   // Consume 5 bytes.
   sequencer_->MarkConsumed(5);
   EXPECT_EQ(8u, stream_.flow_controller()->bytes_consumed());
   // Verify data.
-  const char* expected4[] = {"i"};
-  ASSERT_TRUE(VerifyReadableRegions(expected4, arraysize(expected4)));
+  vector<string> expected4{"i"};
+  ASSERT_TRUE(VerifyReadableRegions(expected4));
   EXPECT_EQ(1u, sequencer_->NumBytesBuffered());
 }
 
-TEST_F(QuicStreamSequencerTest, MarkConsumedError) {
+TEST_P(QuicStreamSequencerTest, MarkConsumedError) {
   EXPECT_CALL(stream_, OnDataAvailable());
 
   OnFrame(0, "abc");
@@ -523,8 +560,8 @@
 
   // Peek into the data.  Only the first chunk should be readable because of the
   // missing data.
-  const char* expected[] = {"abc"};
-  ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
+  vector<string> expected{"abc"};
+  ASSERT_TRUE(VerifyReadableRegions(expected));
 
   // Now, attempt to mark consumed more data than was readable and expect the
   // stream to be closed.
@@ -534,7 +571,7 @@
                 " expect to consume: 4, but not enough bytes available.");
 }
 
-TEST_F(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) {
+TEST_P(QuicStreamSequencerTest, MarkConsumedWithMissingPacket) {
   InSequence s;
   EXPECT_CALL(stream_, OnDataAvailable());
 
@@ -543,8 +580,13 @@
   // Missing packet: 6, ghi.
   OnFrame(9, "jkl");
 
-  const char* expected[] = {"abc", "def"};
-  ASSERT_TRUE(VerifyReadableRegions(expected, arraysize(expected)));
+  vector<string> expected;
+  if (FLAGS_quic_use_stream_sequencer_buffer) {
+    expected = vector<string>{"abcdef"};
+  } else {
+    expected = vector<string>{"abc", "def"};
+  }
+  ASSERT_TRUE(VerifyReadableRegions(expected));
 
   sequencer_->MarkConsumed(6);
 }
@@ -597,7 +639,7 @@
       QuicStreamFrame(1, false, kBufferedOffset + kBufferedDataLength, data)));
 }
 
-TEST_F(QuicStreamSequencerTest, DontAcceptOverlappingFrames) {
+TEST_P(QuicStreamSequencerTest, DontAcceptOverlappingFrames) {
   // The peer should never send us non-identical stream frames which contain
   // overlapping byte ranges - if they do, we close the connection.
 
@@ -610,7 +652,7 @@
   sequencer_->OnStreamFrame(frame2);
 }
 
-TEST_F(QuicStreamSequencerTest, InOrderTimestamps) {
+TEST_P(QuicStreamSequencerTest, InOrderTimestamps) {
   // This test verifies that timestamps returned by
   // GetReadableRegion() are in the correct sequence when frames
   // arrive at the sequencer in order.
@@ -651,7 +693,7 @@
   EXPECT_EQ(0u, sequencer_->NumBytesBuffered());
 }
 
-TEST_F(QuicStreamSequencerTest, OutOfOrderTimestamps) {
+TEST_P(QuicStreamSequencerTest, OutOfOrderTimestamps) {
   // This test verifies that timestamps returned by
   // GetReadableRegion() are in the correct sequence when frames
   // arrive at the sequencer out of order.
diff --git a/net/quic/quic_unacked_packet_map.cc b/net/quic/quic_unacked_packet_map.cc
index ab389ce..7481341 100644
--- a/net/quic/quic_unacked_packet_map.cc
+++ b/net/quic/quic_unacked_packet_map.cc
@@ -51,13 +51,7 @@
   TransmissionInfo info(packet->retransmittable_frames,
                         packet->packet_number_length, transmission_type,
                         sent_time, bytes_sent, packet->is_fec_packet);
-  if (old_packet_number == 0) {
-    if (packet->retransmittable_frames != nullptr &&
-        packet->retransmittable_frames->HasCryptoHandshake() == IS_HANDSHAKE) {
-      ++pending_crypto_packet_count_;
-    }
-    info.ack_listeners.swap(packet->listeners);
-  } else {
+  if (old_packet_number > 0) {
     TransferRetransmissionInfo(old_packet_number, packet_number,
                                transmission_type, &info);
   }
@@ -68,6 +62,15 @@
     info.in_flight = true;
   }
   unacked_packets_.push_back(info);
+  // Swap the ack listeners after to avoid an extra list allocation.
+  // TODO(ianswett): Could use emplace_back when Chromium can.
+  if (old_packet_number == 0) {
+    if (packet->retransmittable_frames != nullptr &&
+        packet->retransmittable_frames->HasCryptoHandshake() == IS_HANDSHAKE) {
+      ++pending_crypto_packet_count_;
+    }
+    unacked_packets_.back().ack_listeners.swap(packet->listeners);
+  }
 }
 
 void QuicUnackedPacketMap::RemoveObsoletePackets() {
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index f4e9a8a..1efad19 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -100,11 +100,6 @@
     }
   }
 
-  if (!FLAGS_quic_stop_checking_for_mismatch_ids && frame.stream_id != id_) {
-    session_->connection()->SendConnectionClose(QUIC_INTERNAL_ERROR);
-    return;
-  }
-
   if (frame.fin) {
     fin_received_ = true;
     if (fin_sent_) {
@@ -186,7 +181,6 @@
 }
 
 void ReliableQuicStream::Reset(QuicRstStreamErrorCode error) {
-  DCHECK_NE(QUIC_STREAM_NO_ERROR, error);
   stream_error_ = error;
   // Sending a RstStream results in calling CloseStream.
   session()->SendRstStream(id(), error, stream_bytes_written_);
diff --git a/net/quic/reliable_quic_stream.h b/net/quic/reliable_quic_stream.h
index a608c32..ab36df0 100644
--- a/net/quic/reliable_quic_stream.h
+++ b/net/quic/reliable_quic_stream.h
@@ -105,10 +105,16 @@
   }
   bool write_side_closed() const { return write_side_closed_; }
 
+  bool rst_received() { return rst_received_; }
+  bool rst_sent() { return rst_sent_; }
+  bool fin_received() { return fin_received_; }
+  bool fin_sent() { return fin_sent_; }
+
   uint64 stream_bytes_read() const { return stream_bytes_read_; }
   uint64 stream_bytes_written() const { return stream_bytes_written_; }
 
   void set_fin_sent(bool fin_sent) { fin_sent_ = fin_sent; }
+  void set_fin_received(bool fin_received) { fin_received_ = fin_received; }
   void set_rst_sent(bool rst_sent) { rst_sent_ = rst_sent; }
 
   void set_fec_policy(FecPolicy fec_policy) { fec_policy_ = fec_policy; }
@@ -189,7 +195,7 @@
   // Close the write side of the socket.  Further writes will fail.
   // Can be called by the subclass or internally.
   // Does not send a FIN.  May cause the stream to be closed.
-  void CloseWriteSide();
+  virtual void CloseWriteSide();
 
   // Helper method that returns FecProtection to use when writing.
   FecProtection GetFecProtection();
diff --git a/net/quic/test_tools/crypto_test_utils.cc b/net/quic/test_tools/crypto_test_utils.cc
index 6d8dae9..cb9ce7ce 100644
--- a/net/quic/test_tools/crypto_test_utils.cc
+++ b/net/quic/test_tools/crypto_test_utils.cc
@@ -58,51 +58,6 @@
   vector<CryptoHandshakeMessage> messages_;
 };
 
-// MovePackets parses crypto handshake messages from packet number
-// |*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++) {
-    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 (const QuicStreamFrame& stream_frame : framer.stream_frames()) {
-      ASSERT_TRUE(crypto_framer.ProcessInput(stream_frame.data));
-      ASSERT_FALSE(crypto_visitor.error());
-    }
-  }
-  *inout_packet_index = index;
-
-  QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
-
-  ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
-
-  for (const CryptoHandshakeMessage& message : crypto_visitor.messages()) {
-    dest_stream->OnHandshakeMessage(message);
-  }
-}
-
 // HexChar parses |c| as a hex character. If valid, it sets |*value| to the
 // value of the hex character and returns true. Otherwise it returns false.
 bool HexChar(char c, uint8* value) {
@@ -166,14 +121,20 @@
 
 }  // anonymous namespace
 
+CryptoTestUtils::FakeServerOptions::FakeServerOptions()
+    : token_binding_enabled(false) {}
+
 CryptoTestUtils::FakeClientOptions::FakeClientOptions()
-    : channel_id_enabled(false), channel_id_source_async(false) {}
+    : channel_id_enabled(false),
+      channel_id_source_async(false),
+      token_binding_enabled(false) {}
 
 // static
 int CryptoTestUtils::HandshakeWithFakeServer(
     MockConnectionHelper* helper,
     PacketSavingConnection* client_conn,
-    QuicCryptoClientStream* client) {
+    QuicCryptoClientStream* client,
+    const FakeServerOptions& options) {
   PacketSavingConnection* server_conn = new PacketSavingConnection(
       helper, Perspective::IS_SERVER, client_conn->supported_versions());
 
@@ -183,7 +144,7 @@
                                        ProofSourceForTesting());
   SetupCryptoServerConfigForTest(server_conn->clock(),
                                  server_conn->random_generator(), &config,
-                                 &crypto_config);
+                                 &crypto_config, options);
 
   TestQuicSpdyServerSession server_session(server_conn, config, &crypto_config);
 
@@ -220,6 +181,9 @@
     }
     crypto_config.SetChannelIDSource(source);
   }
+  if (options.token_binding_enabled) {
+    crypto_config.tb_key_params.push_back(kP256);
+  }
   TestQuicSpdyClientSession client_session(client_conn, DefaultQuicConfig(),
                                            server_id, &crypto_config);
 
@@ -252,9 +216,11 @@
     const QuicClock* clock,
     QuicRandom* rand,
     QuicConfig* config,
-    QuicCryptoServerConfig* crypto_config) {
+    QuicCryptoServerConfig* crypto_config,
+    const FakeServerOptions& fake_options) {
   QuicCryptoServerConfig::ConfigOptions options;
   options.channel_id_enabled = true;
+  options.token_binding_enabled = fake_options.token_binding_enabled;
   scoped_ptr<CryptoHandshakeMessage> scfg(
       crypto_config->AddDefaultConfig(rand, clock, options));
 }
@@ -608,5 +574,47 @@
   return *parsed;
 }
 
+// static
+void CryptoTestUtils::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 ther
+  // 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++) {
+    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 (const QuicStreamFrame& stream_frame : framer.stream_frames()) {
+      ASSERT_TRUE(crypto_framer.ProcessInput(stream_frame.data));
+      ASSERT_FALSE(crypto_visitor.error());
+    }
+  }
+  *inout_packet_index = index;
+
+  QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
+
+  ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
+
+  for (const CryptoHandshakeMessage& message : crypto_visitor.messages()) {
+    dest_stream->OnHandshakeMessage(message);
+  }
+}
+
 }  // namespace test
 }  // namespace net
diff --git a/net/quic/test_tools/crypto_test_utils.h b/net/quic/test_tools/crypto_test_utils.h
index b881b457..b823c61 100644
--- a/net/quic/test_tools/crypto_test_utils.h
+++ b/net/quic/test_tools/crypto_test_utils.h
@@ -54,6 +54,16 @@
     virtual void RunPendingCallbacks() = 0;
   };
 
+  // FakeServerOptions bundles together a number of options for configuring the
+  // server in HandshakeWithFakeServer.
+  struct FakeServerOptions {
+    FakeServerOptions();
+
+    // If token_binding_enabled is true, then the server will attempt to
+    // negotiate Token Binding.
+    bool token_binding_enabled;
+  };
+
   // FakeClientOptions bundles together a number of options for configuring
   // HandshakeWithFakeClient.
   struct FakeClientOptions {
@@ -66,12 +76,17 @@
     // If channel_id_source_async is true then the client will use an async
     // ChannelIDSource for testing. Ignored if channel_id_enabled is false.
     bool channel_id_source_async;
+
+    // If token_binding_enabled is true, then the client will attempt to
+    // negotiate Token Binding.
+    bool token_binding_enabled;
   };
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeServer(MockConnectionHelper* helper,
                                      PacketSavingConnection* client_conn,
-                                     QuicCryptoClientStream* client);
+                                     QuicCryptoClientStream* client,
+                                     const FakeServerOptions& options);
 
   // returns: the number of client hellos that the client sent.
   static int HandshakeWithFakeClient(MockConnectionHelper* helper,
@@ -86,7 +101,8 @@
       const QuicClock* clock,
       QuicRandom* rand,
       QuicConfig* config,
-      QuicCryptoServerConfig* crypto_config);
+      QuicCryptoServerConfig* crypto_config,
+      const FakeServerOptions& options);
 
   // CommunicateHandshakeMessages moves messages from |a| to |b| and back until
   // |a|'s handshake has completed.
@@ -165,6 +181,15 @@
   // method never returns QUIC_PENDING.
   static ChannelIDSource* ChannelIDSourceForTesting();
 
+  // MovePackets parses crypto handshake messages from packet number
+  // |*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.
+  static void MovePackets(PacketSavingConnection* source_conn,
+                          size_t* inout_packet_index,
+                          QuicCryptoStream* dest_stream,
+                          PacketSavingConnection* dest_conn);
+
  private:
   static void CompareClientAndServerKeys(QuicCryptoClientStream* client,
                                          QuicCryptoServerStream* server);
diff --git a/net/quic/test_tools/crypto_test_utils_chromium.cc b/net/quic/test_tools/crypto_test_utils_chromium.cc
index 9978d72c..f6171442 100644
--- a/net/quic/test_tools/crypto_test_utils_chromium.cc
+++ b/net/quic/test_tools/crypto_test_utils_chromium.cc
@@ -137,6 +137,7 @@
   QuicAsyncStatus VerifyProof(const std::string& hostname,
                               const std::string& server_config,
                               const std::vector<std::string>& certs,
+                              const std::string& cert_sct,
                               const std::string& signature,
                               const ProofVerifyContext* verify_context,
                               std::string* error_details,
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index d5fdec2..8e1df7ad 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -545,6 +545,7 @@
                     QuicByteCount,
                     HasRetransmittableData));
   MOCK_METHOD1(OnRetransmissionTimeout, void(bool));
+  MOCK_METHOD0(OnConnectionMigration, void());
   MOCK_METHOD0(RevertRetransmissionTimeout, void());
   MOCK_CONST_METHOD3(TimeUntilSend,
                      QuicTime::Delta(QuicTime now,
@@ -691,7 +692,7 @@
                     QuicPacketNumber,
                     EncryptionLevel,
                     TransmissionType,
-                    const QuicEncryptedPacket&,
+                    size_t encrypted_length,
                     QuicTime));
 
   MOCK_METHOD3(OnPacketReceived,
diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc
index ed5491a..3003929 100644
--- a/net/tools/quic/end_to_end_test.cc
+++ b/net/tools/quic/end_to_end_test.cc
@@ -147,30 +147,51 @@
   // to do 0-RTT across incompatible versions. Chromium only supports
   // a single version at a time anyway. :)
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
-  QuicVersionVector client_version_buckets[2];
+  QuicVersionVector version_buckets[2];
   for (const QuicVersion version : all_supported_versions) {
     if (version <= QUIC_VERSION_25) {
       // SPDY/4
-      client_version_buckets[0].push_back(version);
+      version_buckets[0].push_back(version);
     } else {
       // QUIC_VERSION_26 changes the kdf in a way that is incompatible with
       // version negotiation across the version 26 boundary.
-      client_version_buckets[1].push_back(version);
+      version_buckets[1].push_back(version);
     }
   }
 
   vector<TestParams> params;
-  // TODO(rtenneti): Add kTBBR after BBR code is checked in.
-  // for (const QuicTag congestion_control_tag : {kRENO, kTBBR, kQBIC}) {
-  for (const QuicTag congestion_control_tag : {kRENO, kQBIC}) {
-    for (const bool use_fec : {false, true}) {
-      for (const QuicVersionVector& client_versions : client_version_buckets) {
-        // A number of end to end tests fail when stateless rejects are enabled
-        // *and* there are more than two QUIC versions.
-        for (bool client_supports_stateless_rejects : {true, false}) {
-          for (bool server_uses_stateless_rejects_if_peer_supported :
-               {true, false}) {
-            for (bool auto_tune_flow_control_window : {true, false}) {
+  for (bool server_uses_stateless_rejects_if_peer_supported : {true, false}) {
+    for (bool client_supports_stateless_rejects : {true, false}) {
+      // TODO(rtenneti): Add kTBBR after BBR code is checked in.
+      for (const QuicTag congestion_control_tag : {kRENO, kQBIC}) {
+        for (bool auto_tune_flow_control_window : {true, false}) {
+          for (const bool use_fec : {false, true}) {
+            const int kMaxEnabledOptions = 5;
+            int enabled_options = 0;
+            if (congestion_control_tag != kQBIC) {
+              ++enabled_options;
+            }
+            if (use_fec) {
+              ++enabled_options;
+            }
+            if (auto_tune_flow_control_window) {
+              ++enabled_options;
+            }
+            if (client_supports_stateless_rejects) {
+              ++enabled_options;
+            }
+            if (server_uses_stateless_rejects_if_peer_supported) {
+              ++enabled_options;
+            }
+            CHECK_GE(kMaxEnabledOptions, enabled_options);
+
+            // Run tests with no options, a single option, or all the options
+            // enabled to avoid a combinatorial explosion.
+            if (enabled_options > 1 && enabled_options < kMaxEnabledOptions) {
+              continue;
+            }
+
+            for (const QuicVersionVector& client_versions : version_buckets) {
               CHECK(!client_versions.empty());
               // Add an entry for server and client supporting all versions.
               params.push_back(TestParams(
@@ -179,10 +200,10 @@
                   client_supports_stateless_rejects,
                   server_uses_stateless_rejects_if_peer_supported,
                   congestion_control_tag, auto_tune_flow_control_window));
-              if (client_supports_stateless_rejects &&
-                  server_uses_stateless_rejects_if_peer_supported) {
-                // TODO(b/23745998) Make stateless reject work with version
-                // negotiation.
+
+              // Run version negotiation tests tests with no options, or all
+              // the options enabled to avoid a combinatorial explosion.
+              if (enabled_options > 0 && enabled_options < kMaxEnabledOptions) {
                 continue;
               }
 
@@ -1050,6 +1071,28 @@
   EXPECT_EQ(QUIC_INVALID_STREAM_ID, client_->connection_error());
 }
 
+TEST_P(EndToEndTest, EarlyResponseWithQuicStreamNoError) {
+  ASSERT_TRUE(Initialize());
+  client_->client()->WaitForCryptoHandshakeConfirmed();
+
+  string large_body;
+  GenerateBody(&large_body, 1024 * 1024);
+
+  HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/foo");
+  request.AddBody(large_body, false);
+
+  // Insert an invalid content_length field in request to trigger an early
+  // response from server.
+  request.AddHeader("content-length", "-3");
+
+  request.set_skip_message_validation(true);
+  client_->SendCustomSynchronousRequest(request);
+  EXPECT_EQ("bad", client_->response_body());
+  EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
+  EXPECT_EQ(QUIC_STREAM_NO_ERROR, client_->stream_error());
+  EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
+}
+
 // TODO(rch): this test seems to cause net_unittests timeouts :|
 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
   ASSERT_TRUE(Initialize());
@@ -1776,14 +1819,9 @@
   // Send the version negotiation packet.
   QuicConnectionId incorrect_connection_id =
       client_->client()->session()->connection()->connection_id() + 1;
-  QuicVersionNegotiationPacket header;
-  header.connection_id = incorrect_connection_id;
-  header.reset_flag = true;
-  header.version_flag = true;
-  QuicFramer framer(server_supported_versions_, QuicTime::Zero(),
-                    Perspective::IS_SERVER);
   scoped_ptr<QuicEncryptedPacket> packet(
-      framer.BuildVersionNegotiationPacket(header, server_supported_versions_));
+      QuicFramer::BuildVersionNegotiationPacket(incorrect_connection_id,
+                                                server_supported_versions_));
   testing::NiceMock<MockQuicConnectionDebugVisitor> visitor;
   client_->client()->session()->connection()->set_debug_visitor(&visitor);
   EXPECT_CALL(visitor, OnIncorrectConnectionId(incorrect_connection_id))
@@ -2064,6 +2102,17 @@
   // Receive the response and let the server close writing.
   client_->WaitForInitialResponse();
   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
+
+  if (negotiated_version_ > QUIC_VERSION_28) {
+    // Receive the reset stream from server on early response.
+    client_->WaitForResponseForMs(100);
+    ReliableQuicStream* stream =
+        client_->client()->session()->GetStream(kClientDataStreamId1);
+    // The stream is reset by server's reset stream.
+    EXPECT_EQ(stream, nullptr);
+    return;
+  }
+
   // Send a body larger than the stream flow control window.
   string body;
   GenerateBody(&body, kBodySize);
@@ -2074,13 +2123,14 @@
     // (This is OK despite already waiting for a response.)
     client_->WaitForResponse();
     // There should be no buffered data to write in the client's stream.
-    ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
+    ReliableQuicStream* stream =
+        client_->client()->session()->GetStream(kClientDataStreamId1);
     EXPECT_FALSE(stream != nullptr && stream->HasBufferedData());
   } else {
     // Run the client for 0.1 second to let any buffered data be sent.
     // Must have a timeout, as the stream will not close and cause a return.
     // (This is OK despite already waiting for a response.)
-    client_->WaitForResponseForMs(static_cast<int64>(100));
+    client_->WaitForResponseForMs(100);
     // There will be buffered data to write in the client's stream.
     ReliableQuicStream* stream = client_->client()->session()->GetStream(5);
     EXPECT_TRUE(stream != nullptr && stream->HasBufferedData());
diff --git a/net/tools/quic/quic_client_bin.cc b/net/tools/quic/quic_client_bin.cc
index 5b214a86..e5cc288 100644
--- a/net/tools/quic/quic_client_bin.cc
+++ b/net/tools/quic/quic_client_bin.cc
@@ -19,7 +19,7 @@
 //   quic_client https://www.google.com --port=443  --host=${IP}
 //
 // Use a specific version:
-//   quic_client http://www.google.com --version=23  --host=${IP}
+//   quic_client http://www.google.com --quic_version=23  --host=${IP}
 //
 // Send a POST instead of a GET:
 //   quic_client http://www.google.com --body="this is a POST body" --host=${IP}
diff --git a/net/tools/quic/quic_client_session_test.cc b/net/tools/quic/quic_client_session_test.cc
index 7ae923bf..67718c1a 100644
--- a/net/tools/quic/quic_client_session_test.cc
+++ b/net/tools/quic/quic_client_session_test.cc
@@ -62,7 +62,9 @@
     session_->CryptoConnect();
     QuicCryptoClientStream* stream =
         static_cast<QuicCryptoClientStream*>(session_->GetCryptoStream());
-    CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_, stream);
+    CryptoTestUtils::FakeServerOptions options;
+    CryptoTestUtils::HandshakeWithFakeServer(&helper_, connection_, stream,
+                                             options);
   }
 
   QuicCryptoClientConfig crypto_config_;
diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index efe6acc..ba110dd 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -64,10 +64,12 @@
     crypto_stream_ = crypto_stream;
   }
 
-  QuicCryptoServerStream* GetCryptoStream() override { return crypto_stream_; }
+  QuicCryptoServerStreamBase* GetCryptoStream() override {
+    return crypto_stream_;
+  }
 
  private:
-  QuicCryptoServerStream* crypto_stream_;
+  QuicCryptoServerStreamBase* crypto_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestQuicSpdyServerSession);
 };
@@ -408,7 +410,7 @@
     session1_->SetCryptoStream(crypto_stream1_);
     crypto_stream1_->set_handshake_confirmed_for_testing(
         GetParam().crypto_handshake_successful);
-    crypto_stream1_->set_peer_supports_stateless_rejects(
+    crypto_stream1_->SetPeerSupportsStatelessRejects(
         GetParam().client_supports_statelesss_rejects);
     return session1_;
   }
diff --git a/net/tools/quic/quic_server_session.cc b/net/tools/quic/quic_server_session.cc
index 33d7cef..423b99b 100644
--- a/net/tools/quic/quic_server_session.cc
+++ b/net/tools/quic/quic_server_session.cc
@@ -35,7 +35,7 @@
   QuicSpdySession::Initialize();
 }
 
-QuicCryptoServerStream* QuicServerSession::CreateQuicCryptoServerStream(
+QuicCryptoServerStreamBase* QuicServerSession::CreateQuicCryptoServerStream(
     const QuicCryptoServerConfig* crypto_config) {
   return new QuicCryptoServerStream(crypto_config, this);
 }
@@ -51,7 +51,7 @@
   // region, then pass it to the sent packet manager in preparation for possible
   // bandwidth resumption.
   const CachedNetworkParameters* cached_network_params =
-      crypto_stream_->previous_cached_network_params();
+      crypto_stream_->PreviousCachedNetworkParams();
   const bool last_bandwidth_resumption =
       ContainsQuicTag(config()->ReceivedConnectionOptions(), kBWRE);
   const bool max_bandwidth_resumption =
@@ -210,7 +210,7 @@
   return nullptr;
 }
 
-QuicCryptoServerStream* QuicServerSession::GetCryptoStream() {
+QuicCryptoServerStreamBase* QuicServerSession::GetCryptoStream() {
   return crypto_stream_.get();
 }
 
diff --git a/net/tools/quic/quic_server_session.h b/net/tools/quic/quic_server_session.h
index 654d1ce8..bce73a72 100644
--- a/net/tools/quic/quic_server_session.h
+++ b/net/tools/quic/quic_server_session.h
@@ -70,7 +70,7 @@
 
   void Initialize() override;
 
-  const QuicCryptoServerStream* crypto_stream() const {
+  const QuicCryptoServerStreamBase* crypto_stream() const {
     return crypto_stream_.get();
   }
 
@@ -81,14 +81,14 @@
     if (GetCryptoStream() == nullptr) {
       return false;
     }
-    return GetCryptoStream()->use_stateless_rejects_if_peer_supported();
+    return GetCryptoStream()->UseStatelessRejectsIfPeerSupported();
   }
 
   bool PeerSupportsStatelessRejects() {
     if (GetCryptoStream() == nullptr) {
       return false;
     }
-    return GetCryptoStream()->peer_supports_stateless_rejects();
+    return GetCryptoStream()->PeerSupportsStatelessRejects();
   }
 
   void set_serving_region(const std::string& serving_region) {
@@ -99,21 +99,23 @@
   // QuicSession methods:
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override;
   QuicSpdyStream* CreateOutgoingDynamicStream() override;
-  QuicCryptoServerStream* GetCryptoStream() override;
+  QuicCryptoServerStreamBase* GetCryptoStream() override;
 
   // If we should create an incoming stream, returns true. Otherwise
   // does error handling, including communicating the error to the client and
   // possibly closing the connection, and returns false.
   virtual bool ShouldCreateIncomingDynamicStream(QuicStreamId id);
 
-  virtual QuicCryptoServerStream* CreateQuicCryptoServerStream(
+  virtual QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
       const QuicCryptoServerConfig* crypto_config);
 
+  const QuicCryptoServerConfig* crypto_config() { return crypto_config_; }
+
  private:
   friend class test::QuicServerSessionPeer;
 
   const QuicCryptoServerConfig* crypto_config_;
-  scoped_ptr<QuicCryptoServerStream> crypto_stream_;
+  scoped_ptr<QuicCryptoServerStreamBase> crypto_stream_;
   QuicServerSessionVisitor* visitor_;
 
   // Whether bandwidth resumption is enabled for this connection.
diff --git a/net/tools/quic/quic_server_session_test.cc b/net/tools/quic/quic_server_session_test.cc
index 2b1b961..173ea53 100644
--- a/net/tools/quic/quic_server_session_test.cc
+++ b/net/tools/quic/quic_server_session_test.cc
@@ -455,21 +455,21 @@
   CachedNetworkParameters cached_network_params;
   cached_network_params.set_bandwidth_estimate_bytes_per_second(1);
   cached_network_params.set_serving_region("different serving region");
-  crypto_stream->set_previous_cached_network_params(cached_network_params);
+  crypto_stream->SetPreviousCachedNetworkParams(cached_network_params);
   EXPECT_CALL(*connection_, ResumeConnectionState(_, _)).Times(0);
   session_->OnConfigNegotiated();
 
   // Same serving region, but timestamp is too old, should have no effect.
   cached_network_params.set_serving_region(kTestServingRegion);
   cached_network_params.set_timestamp(0);
-  crypto_stream->set_previous_cached_network_params(cached_network_params);
+  crypto_stream->SetPreviousCachedNetworkParams(cached_network_params);
   EXPECT_CALL(*connection_, ResumeConnectionState(_, _)).Times(0);
   session_->OnConfigNegotiated();
 
   // Same serving region, and timestamp is recent: estimate is stored.
   cached_network_params.set_timestamp(
       connection_->clock()->WallNow().ToUNIXSeconds());
-  crypto_stream->set_previous_cached_network_params(cached_network_params);
+  crypto_stream->SetPreviousCachedNetworkParams(cached_network_params);
   EXPECT_CALL(*connection_, ResumeConnectionState(_, _)).Times(1);
   session_->OnConfigNegotiated();
 }
diff --git a/net/tools/quic/quic_simple_client_bin.cc b/net/tools/quic/quic_simple_client_bin.cc
index 69e68ad..aec114db 100644
--- a/net/tools/quic/quic_simple_client_bin.cc
+++ b/net/tools/quic/quic_simple_client_bin.cc
@@ -19,7 +19,7 @@
 //   quic_client https://www.google.com --port=443  --host=${IP}
 //
 // Use a specific version:
-//   quic_client http://www.google.com --version=23  --host=${IP}
+//   quic_client http://www.google.com --quic_version=23  --host=${IP}
 //
 // Send a POST instead of a GET:
 //   quic_client http://www.google.com --body="this is a POST body" --host=${IP}
diff --git a/net/tools/quic/quic_spdy_server_stream_test.cc b/net/tools/quic/quic_spdy_server_stream_test.cc
index dedb272..3ff6fe7 100644
--- a/net/tools/quic/quic_spdy_server_stream_test.cc
+++ b/net/tools/quic/quic_spdy_server_stream_test.cc
@@ -77,11 +77,13 @@
 
 namespace {
 
-class QuicSpdyServerStreamTest : public ::testing::Test {
+class QuicSpdyServerStreamTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   QuicSpdyServerStreamTest()
       : connection_(
-            new StrictMock<MockConnection>(&helper_, Perspective::IS_SERVER)),
+            new StrictMock<MockConnection>(&helper_,
+                                           Perspective::IS_SERVER,
+                                           SupportedVersions(GetParam()))),
         session_(connection_),
         body_("hello world") {
     SpdyHeaderBlock request_headers;
@@ -144,7 +146,11 @@
   return QuicConsumedData(data.total_length, fin);
 }
 
-TEST_F(QuicSpdyServerStreamTest, TestFraming) {
+INSTANTIATE_TEST_CASE_P(Tests,
+                        QuicSpdyServerStreamTest,
+                        ::testing::ValuesIn(QuicSupportedVersions()));
+
+TEST_P(QuicSpdyServerStreamTest, TestFraming) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
   stream_->OnStreamHeaders(headers_string_);
@@ -157,7 +163,7 @@
   EXPECT_EQ(body_, StreamBody());
 }
 
-TEST_F(QuicSpdyServerStreamTest, TestFramingOnePacket) {
+TEST_P(QuicSpdyServerStreamTest, TestFramingOnePacket) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
 
@@ -171,12 +177,32 @@
   EXPECT_EQ(body_, StreamBody());
 }
 
-TEST_F(QuicSpdyServerStreamTest, TestFramingExtraData) {
+TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+      .Times(AnyNumber())
+      .WillRepeatedly(Invoke(ConsumeAllData));
+
+  EXPECT_FALSE(stream_->fin_received());
+  EXPECT_FALSE(stream_->rst_received());
+
+  stream_->set_fin_sent(true);
+  stream_->CloseWriteSide();
+
+  if (GetParam() > QUIC_VERSION_28) {
+    EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
+  } else {
+    EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+  }
+  stream_->StopReading();
+}
+
+TEST_P(QuicSpdyServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(AnyNumber()).
       WillRepeatedly(Invoke(ConsumeAllData));
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(false, headers_string_.size());
@@ -185,13 +211,13 @@
   // Content length is still 11.  This will register as an error and we won't
   // accept the bytes.
   stream_->OnStreamFrame(
-      QuicStreamFrame(stream_->id(), /*fin=*/false, body_.size(), large_body));
+      QuicStreamFrame(stream_->id(), /*fin=*/true, body_.size(), large_body));
   EXPECT_EQ("11", StreamHeadersValue("content-length"));
   EXPECT_EQ("/", StreamHeadersValue(":path"));
   EXPECT_EQ("POST", StreamHeadersValue(":method"));
 }
 
-TEST_F(QuicSpdyServerStreamTest, TestSendResponse) {
+TEST_P(QuicSpdyServerStreamTest, TestSendResponse) {
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/foo";
   (*request_headers)[":authority"] = "";
@@ -201,6 +227,7 @@
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "200 OK";
   response_headers_["content-length"] = "3";
+  stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, 0, false, _, nullptr));
@@ -217,10 +244,13 @@
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_F(QuicSpdyServerStreamTest, TestSendErrorResponse) {
+TEST_P(QuicSpdyServerStreamTest, TestSendErrorResponse) {
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "500 Server Error";
   response_headers_["content-length"] = "3";
+  stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, 0, false, _, nullptr));
@@ -237,7 +267,9 @@
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_F(QuicSpdyServerStreamTest, InvalidMultipleContentLength) {
+TEST_P(QuicSpdyServerStreamTest, InvalidMultipleContentLength) {
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("11\00012", 5);
@@ -247,20 +279,17 @@
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(ConsumeAllData));
-
   stream_->OnStreamHeaders(headers_string_);
-  stream_->OnStreamHeadersComplete(false, headers_string_.size());
+  stream_->OnStreamHeadersComplete(true, headers_string_.size());
 
-  if (!FLAGS_quic_implement_stop_reading) {
-    EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
-  } else {
-    EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
-  }
+  EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_F(QuicSpdyServerStreamTest, InvalidLeadingNullContentLength) {
+TEST_P(QuicSpdyServerStreamTest, InvalidLeadingNullContentLength) {
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("\00012", 3);
@@ -270,20 +299,15 @@
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(ConsumeAllData));
-
   stream_->OnStreamHeaders(headers_string_);
-  stream_->OnStreamHeadersComplete(false, headers_string_.size());
+  stream_->OnStreamHeadersComplete(true, headers_string_.size());
 
-  if (!FLAGS_quic_implement_stop_reading) {
-    EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
-  } else {
-    EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
-  }
+  EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_F(QuicSpdyServerStreamTest, ValidMultipleContentLength) {
+TEST_P(QuicSpdyServerStreamTest, ValidMultipleContentLength) {
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("11\00011", 5);
@@ -299,7 +323,46 @@
   EXPECT_FALSE(stream_->write_side_closed());
 }
 
-TEST_F(QuicSpdyServerStreamTest, InvalidHeadersWithFin) {
+TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
+  response_headers_[":version"] = "HTTP/1.1";
+  response_headers_[":status"] = "500 Server Error";
+  response_headers_["content-length"] = "3";
+
+  InSequence s;
+
+  EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, 0, false, _, nullptr));
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+      .Times(1)
+      .WillOnce(Return(QuicConsumedData(3, true)));
+  if (GetParam() > QUIC_VERSION_28) {
+    EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1);
+  } else {
+    EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+  }
+  EXPECT_FALSE(stream_->fin_received());
+  QuicSpdyServerStreamPeer::SendErrorResponse(stream_);
+  EXPECT_TRUE(stream_->reading_stopped());
+  EXPECT_TRUE(stream_->write_side_closed());
+}
+
+TEST_P(QuicSpdyServerStreamTest, DoNotSendQuicRstStreamNoErrorWithRstReceived) {
+  response_headers_[":version"] = "HTTP/1.1";
+  response_headers_[":status"] = "500 Server Error";
+  response_headers_["content-length"] = "3";
+
+  InSequence s;
+  EXPECT_FALSE(stream_->reading_stopped());
+
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
+  EXPECT_CALL(session_, SendRstStream(_, QUIC_RST_ACKNOWLEDGEMENT, _)).Times(1);
+  QuicRstStreamFrame rst_frame(stream_->id(), QUIC_STREAM_CANCELLED, 1234);
+  stream_->OnStreamReset(rst_frame);
+
+  EXPECT_TRUE(stream_->reading_stopped());
+  EXPECT_TRUE(stream_->write_side_closed());
+}
+
+TEST_P(QuicSpdyServerStreamTest, InvalidHeadersWithFin) {
   char arr[] = {
     0x3a, 0x68, 0x6f, 0x73,  // :hos
     0x74, 0x00, 0x00, 0x00,  // t...
diff --git a/net/tools/quic/test_tools/quic_test_client.cc b/net/tools/quic/test_tools/quic_test_client.cc
index 276daae..b6f1768 100644
--- a/net/tools/quic/test_tools/quic_test_client.cc
+++ b/net/tools/quic/test_tools/quic_test_client.cc
@@ -46,6 +46,7 @@
   QuicAsyncStatus VerifyProof(const string& hostname,
                               const string& server_config,
                               const vector<string>& certs,
+                              const string& cert_sct,
                               const string& signature,
                               const ProofVerifyContext* context,
                               string* error_details,
@@ -71,13 +72,18 @@
     //    }
     //
     //    common_name_ = cert->subject().GetDisplayName();
+    cert_sct_ = cert_sct;
+
     return QUIC_SUCCESS;
   }
 
   const string& common_name() const { return common_name_; }
 
+  const string& cert_sct() const { return cert_sct_; }
+
  private:
   string common_name_;
+  string cert_sct_;
 };
 
 }  // anonymous namespace
@@ -387,6 +393,11 @@
       ->common_name();
 }
 
+const string& QuicTestClient::cert_sct() const {
+  return reinterpret_cast<RecordingProofVerifier*>(client_->proof_verifier())
+      ->cert_sct();
+}
+
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   QuicCryptoClientConfig* config = client_->crypto_config();
   QuicCryptoClientConfig::CachedState* state =
diff --git a/net/tools/quic/test_tools/quic_test_client.h b/net/tools/quic/test_tools/quic_test_client.h
index 0bf9baa..4d54f18 100644
--- a/net/tools/quic/test_tools/quic_test_client.h
+++ b/net/tools/quic/test_tools/quic_test_client.h
@@ -161,6 +161,10 @@
   // or the empty string if no certificate was presented.
   const std::string& cert_common_name() const;
 
+  // cert_sct returns the signed timestamp of the server's certificate,
+  // or the empty string if no signed timestamp was presented.
+  const std::string& cert_sct() const;
+
   // Get the server config map.
   QuicTagValueMap GetServerConfig() const;
 
diff --git a/net/tools/quic/test_tools/quic_test_server.cc b/net/tools/quic/test_tools/quic_test_server.cc
index 8d5bd487..baf33af 100644
--- a/net/tools/quic/test_tools/quic_test_server.cc
+++ b/net/tools/quic/test_tools/quic_test_server.cc
@@ -28,23 +28,38 @@
 
 class CustomStreamSession : public QuicServerSession {
  public:
-  CustomStreamSession(const QuicConfig& config,
-                      QuicConnection* connection,
-                      QuicServerSessionVisitor* visitor,
-                      const QuicCryptoServerConfig* crypto_config,
-                      QuicTestServer::StreamFactory* factory)
+  CustomStreamSession(
+      const QuicConfig& config,
+      QuicConnection* connection,
+      QuicServerSessionVisitor* visitor,
+      const QuicCryptoServerConfig* crypto_config,
+      QuicTestServer::StreamFactory* factory,
+      QuicTestServer::CryptoStreamFactory* crypto_stream_factory)
       : QuicServerSession(config, connection, visitor, crypto_config),
-        stream_factory_(factory) {}
+        stream_factory_(factory),
+        crypto_stream_factory_(crypto_stream_factory) {}
 
   QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
     if (!ShouldCreateIncomingDynamicStream(id)) {
       return nullptr;
     }
-    return stream_factory_->CreateStream(id, this);
+    if (stream_factory_) {
+      return stream_factory_->CreateStream(id, this);
+    }
+    return QuicServerSession::CreateIncomingDynamicStream(id);
+  }
+
+  QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
+      const QuicCryptoServerConfig* crypto_config) override {
+    if (crypto_stream_factory_) {
+      return crypto_stream_factory_->CreateCryptoStream(crypto_config, this);
+    }
+    return QuicServerSession::CreateQuicCryptoServerStream(crypto_config);
   }
 
  private:
-  QuicTestServer::StreamFactory* stream_factory_;  // Not owned.
+  QuicTestServer::StreamFactory* stream_factory_;               // Not owned.
+  QuicTestServer::CryptoStreamFactory* crypto_stream_factory_;  // Not owned.
 };
 
 class QuicTestDispatcher : public QuicDispatcher {
@@ -56,11 +71,13 @@
                      QuicConnectionHelperInterface* helper)
       : QuicDispatcher(config, crypto_config, versions, factory, helper),
         session_factory_(nullptr),
-        stream_factory_(nullptr) {}
+        stream_factory_(nullptr),
+        crypto_stream_factory_(nullptr) {}
 
   QuicServerSession* CreateQuicSession(QuicConnectionId id,
                                        const IPEndPoint& client) override {
-    if (session_factory_ == nullptr && stream_factory_ == nullptr) {
+    if (session_factory_ == nullptr && stream_factory_ == nullptr &&
+        crypto_stream_factory_ == nullptr) {
       return QuicDispatcher::CreateQuicSession(id, client);
     }
     QuicConnection* connection = new QuicConnection(
@@ -68,9 +85,10 @@
         /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions());
 
     QuicServerSession* session = nullptr;
-    if (stream_factory_ != nullptr) {
-      session = new CustomStreamSession(config(), connection, this,
-                                        crypto_config(), stream_factory_);
+    if (stream_factory_ != nullptr || crypto_stream_factory_ != nullptr) {
+      session =
+          new CustomStreamSession(config(), connection, this, crypto_config(),
+                                  stream_factory_, crypto_stream_factory_);
     } else {
       session = session_factory_->CreateSession(config(), connection, this,
                                                 crypto_config());
@@ -82,6 +100,7 @@
   void set_session_factory(QuicTestServer::SessionFactory* factory) {
     DCHECK(session_factory_ == nullptr);
     DCHECK(stream_factory_ == nullptr);
+    DCHECK(crypto_stream_factory_ == nullptr);
     session_factory_ = factory;
   }
 
@@ -91,13 +110,20 @@
     stream_factory_ = factory;
   }
 
+  void set_crypto_stream_factory(QuicTestServer::CryptoStreamFactory* factory) {
+    DCHECK(session_factory_ == nullptr);
+    DCHECK(crypto_stream_factory_ == nullptr);
+    crypto_stream_factory_ = factory;
+  }
+
   QuicTestServer::SessionFactory* session_factory() { return session_factory_; }
 
   QuicTestServer::StreamFactory* stream_factory() { return stream_factory_; }
 
  private:
-  QuicTestServer::SessionFactory* session_factory_;  // Not owned.
-  QuicTestServer::StreamFactory* stream_factory_;    // Not owned.
+  QuicTestServer::SessionFactory* session_factory_;             // Not owned.
+  QuicTestServer::StreamFactory* stream_factory_;               // Not owned.
+  QuicTestServer::CryptoStreamFactory* crypto_stream_factory_;  // Not owned.
 };
 
 QuicTestServer::QuicTestServer(ProofSource* proof_source)
@@ -124,6 +150,11 @@
   static_cast<QuicTestDispatcher*>(dispatcher())->set_stream_factory(factory);
 }
 
+void QuicTestServer::SetCryptoStreamFactory(CryptoStreamFactory* factory) {
+  static_cast<QuicTestDispatcher*>(dispatcher())
+      ->set_crypto_stream_factory(factory);
+}
+
 ///////////////////////////   TEST SESSIONS ///////////////////////////////
 
 ImmediateGoAwaySession::ImmediateGoAwaySession(
diff --git a/net/tools/quic/test_tools/quic_test_server.h b/net/tools/quic/test_tools/quic_test_server.h
index 6a027632..da97ccdb 100644
--- a/net/tools/quic/test_tools/quic_test_server.h
+++ b/net/tools/quic/test_tools/quic_test_server.h
@@ -49,6 +49,16 @@
                                                QuicSpdySession* session) = 0;
   };
 
+  class CryptoStreamFactory {
+   public:
+    virtual ~CryptoStreamFactory() {}
+
+    // Returns a new QuicCryptoServerStreamBase owned by the caller
+    virtual QuicCryptoServerStreamBase* CreateCryptoStream(
+        const QuicCryptoServerConfig* crypto_config,
+        QuicSpdySession* session) = 0;
+  };
+
   explicit QuicTestServer(ProofSource* proof_source);
   QuicTestServer(ProofSource* proof_source,
                  const QuicConfig& config,
@@ -58,12 +68,17 @@
   QuicDispatcher* CreateQuicDispatcher() override;
 
   // Sets a custom session factory, owned by the caller, for easy custom
-  // session logic. This is incompatible with setting a stream factory.
+  // session logic. This is incompatible with setting a stream factory or a
+  // crypto stream factory.
   void SetSessionFactory(SessionFactory* factory);
 
   // Sets a custom stream factory, owned by the caller, for easy custom
   // stream logic. This is incompatible with setting a session factory.
   void SetSpdyStreamFactory(StreamFactory* factory);
+
+  // Sets a custom crypto stream factory, owned by the caller, for easy custom
+  // crypto logic.  This is incompatible with setting a session factory.
+  void SetCryptoStreamFactory(CryptoStreamFactory* factory);
 };
 
 // Useful test sessions for the QuicTestServer.