When talking >=QUIC_VERSION_22, regularly send updated bandwidth

net/quic/crypto/quic_crypto_server_config.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/crypto/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/stl_util.h"
@@ skipping 757 matching lines @@
   out->set_tag(kSHLO);
   QuicTagVector supported_version_tags;
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     supported_version_tags.push_back
         (QuicVersionToQuicTag(supported_versions[i]));
   }
   out->SetVector(kVER, supported_version_tags);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(
                           *requested_config,
-                          client_address, rand,
-                          info.now));
+                          client_address,
+                          rand,
+                          info.now,
+                          NULL));
   QuicSocketAddressCoder address_coder(client_address);
   out->SetStringPiece(kCADR, address_coder.Encode());
   out->SetStringPiece(kPUBS, forward_secure_public_value);
 
   return QUIC_NO_ERROR;
 }
 
 scoped_refptr<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfig::GetConfigWithScid(StringPiece requested_scid) const {
   // In Chromium, we will dead lock if the lock is held by the current thread.
@@ skipping 247 matching lines @@
       info->now,
       new VerifyNonceIsValidAndUniqueCallback(client_hello_state, done_cb));
   helper.StartedAsyncCallback();
 }
 
 bool QuicCryptoServerConfig::BuildServerConfigUpdateMessage(
     const IPEndPoint& client_ip,
     const QuicClock* clock,
     QuicRandom* rand,
     const QuicCryptoNegotiatedParameters& params,
+    const CachedNetworkParameters* cached_network_params,
     CryptoHandshakeMessage* out) const {
   base::AutoLock locked(configs_lock_);
   out->set_tag(kSCUP);
   out->SetStringPiece(kSCFG, primary_config_->serialized);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(*primary_config_,
                                             client_ip,
                                             rand,
-                                            clock->WallNow()));
+                                            clock->WallNow(),
+                                            cached_network_params));
 
   if (proof_source_ == NULL) {
     // Insecure QUIC, can send SCFG without proof.
     return true;
   }
 
   const vector<string>* certs;
   string signature;
   if (!proof_source_->GetProof(params.sni, primary_config_->serialized,
                                params.x509_ecdsa_supported, &certs,
@@ skipping 18 matching lines @@
     QuicRandom* rand,
     QuicCryptoNegotiatedParameters *params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kREJ);
   out->SetStringPiece(kSCFG, config.serialized);
   out->SetStringPiece(kSourceAddressTokenTag,
                       NewSourceAddressToken(
                           config,
                           info.client_ip,
                           rand,
-                          info.now));
+                          info.now,
+                          NULL));
   if (replay_protection_) {
     out->SetStringPiece(kServerNonceTag, NewServerNonce(rand, info.now));
   }
 
   if (FLAGS_send_quic_crypto_reject_reason) {
     // Send client the reject reason for debugging purposes.
     DCHECK_LT(0u, info.reject_reasons.size());
     out->SetVector(kRREJ, info.reject_reasons);
   }
 
@@ skipping 297 matching lines @@
   DCHECK(!server_nonce_strike_register_.get());
   server_nonce_strike_register_window_secs_ = window_secs;
 }
 
 void QuicCryptoServerConfig::AcquirePrimaryConfigChangedCb(
     PrimaryConfigChangedCallback* cb) {
   base::AutoLock locked(configs_lock_);
   primary_config_changed_cb_.reset(cb);
 }
 
-string QuicCryptoServerConfig::NewSourceAddressToken(const Config& config,
-                                                     const IPEndPoint& ip,
-                                                     QuicRandom* rand,
-                                                     QuicWallTime now) const {
-  SourceAddressToken source_address_token;
+string QuicCryptoServerConfig::NewSourceAddressToken(
+    const Config& config,
+    const IPEndPoint& ip,
+    QuicRandom* rand,
+    QuicWallTime now,
+    const CachedNetworkParameters* cached_network_params) const {
   IPAddressNumber ip_address = ip.address();
   if (ip.GetSockAddrFamily() == AF_INET) {
     ip_address = ConvertIPv4NumberToIPv6Number(ip_address);
   }
+  SourceAddressToken source_address_token;
   source_address_token.set_ip(IPAddressToPackedString(ip_address));
   source_address_token.set_timestamp(now.ToUNIXSeconds());
+  if (cached_network_params != NULL) {
+    source_address_token.set_cached_network_parameters(*cached_network_params);
+  }
 
   return config.source_address_token_boxer->Box(
       rand, source_address_token.SerializeAsString());
 }
 
 HandshakeFailureReason QuicCryptoServerConfig::ValidateSourceAddressToken(
     const Config& config,
     StringPiece token,
     const IPEndPoint& ip,
     QuicWallTime now) const {
@@ skipping 121 matching lines @@
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0),
       source_address_token_boxer(NULL) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net