QUIC: if client provides an STK which includes CachedNetworkParams, then

net/quic/crypto/quic_crypto_server_config_test.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 <stdarg.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_secret_boxer.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/strike_register_client.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::map;
 using std::pair;
@@ skipping 19 matching lines @@
   }
 
   bool ConfigHasDefaultSourceAddressTokenBoxer(string config_id) {
     scoped_refptr<QuicCryptoServerConfig::Config> config = GetConfig(config_id);
     return config->source_address_token_boxer ==
         &(server_config_->default_source_address_token_boxer_);
   }
 
   string NewSourceAddressToken(
       string config_id,
-      IPEndPoint ip,
+      const IPEndPoint& ip,
       QuicRandom* rand,
       QuicWallTime now) {
+    return NewSourceAddressToken(config_id, ip, rand, now, NULL);
+  }
+
+  string NewSourceAddressToken(
+      string config_id,
+      const IPEndPoint& ip,
+      QuicRandom* rand,
+      QuicWallTime now,
+      CachedNetworkParameters* cached_network_params) {
     return server_config_->NewSourceAddressToken(
-        *GetConfig(config_id), ip, rand, now, nullptr);
+        *GetConfig(config_id), ip, rand, now, cached_network_params);
   }
 
   HandshakeFailureReason ValidateSourceAddressToken(string config_id,
                                                     StringPiece srct,
-                                                    IPEndPoint ip,
+                                                    const IPEndPoint& ip,
                                                     QuicWallTime now) {
+    return ValidateSourceAddressToken(config_id, srct, ip, now, NULL);
+  }
+
+  HandshakeFailureReason ValidateSourceAddressToken(
+      string config_id,
+      StringPiece srct,
+      const IPEndPoint& ip,
+      QuicWallTime now,
+      CachedNetworkParameters* cached_network_params) {
     return server_config_->ValidateSourceAddressToken(
-        *GetConfig(config_id), srct, ip, now);
+        *GetConfig(config_id), srct, ip, now, cached_network_params);
   }
 
   string NewServerNonce(QuicRandom* rand, QuicWallTime now) const {
     return server_config_->NewServerNonce(rand, now);
   }
 
   HandshakeFailureReason ValidateServerNonce(StringPiece token,
                                              QuicWallTime now) {
     return server_config_->ValidateServerNonce(token, now);
   }
@@ skipping 156 matching lines @@
       new TestStrikeRegisterClient(&server);
   server.SetStrikeRegisterClient(strike_register);
 
   QuicCryptoServerConfig::ConfigOptions options;
   scoped_ptr<CryptoHandshakeMessage>(
       server.AddDefaultConfig(rand, &clock, options));
   EXPECT_TRUE(strike_register->is_known_orbit_called());
 }
 
 TEST(QuicCryptoServerConfigTest, SourceAddressTokens) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_store_cached_network_params_from_chlo,
+                              true);
   const string kPrimary = "<primary>";
   const string kOverride = "Config with custom source address token key";
 
   MockClock clock;
   clock.AdvanceTime(QuicTime::Delta::FromSeconds(1000000));
 
   QuicWallTime now = clock.WallNow();
   const QuicWallTime original_time = now;
 
   QuicRandom* rand = QuicRandom::GetInstance();
@@ skipping 68 matching lines @@
                                             now));
 
   // Validation fails after tokens expire.
   now = original_time.Add(QuicTime::Delta::FromSeconds(86400 * 7));
   DCHECK_EQ(SOURCE_ADDRESS_TOKEN_EXPIRED_FAILURE,
             peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
 
   now = original_time.Subtract(QuicTime::Delta::FromSeconds(3600 * 2));
   DCHECK_EQ(SOURCE_ADDRESS_TOKEN_CLOCK_SKEW_FAILURE,
             peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
+
+  // Make sure that if the source address token contains CachedNetworkParameters
+  // that this gets written to ValidateSourceAddressToken output argument.
+  CachedNetworkParameters cached_network_params_input;
+  cached_network_params_input.set_bandwidth_estimate_bytes_per_second(1234);
+  const string token4_with_cached_network_params = peer.NewSourceAddressToken(
+      kPrimary, ip4, rand, now, &cached_network_params_input);
+
+  CachedNetworkParameters cached_network_params_output;
+  EXPECT_NE(cached_network_params_output, cached_network_params_input);
+  peer.ValidateSourceAddressToken(kPrimary, token4_with_cached_network_params,
+                                  ip4, now, &cached_network_params_output);
+  // TODO(rtenneti): For server, enable the following check after serialization
+  // of optional CachedNetworkParameters is implemented.
+  // EXPECT_EQ(cached_network_params_output, cached_network_params_input);
 }
 
 TEST(QuicCryptoServerConfigTest, ValidateServerNonce) {
   QuicRandom* rand = QuicRandom::GetInstance();
   QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
   QuicCryptoServerConfigPeer peer(&server);
 
   StringPiece message("hello world");
   const size_t key_size = CryptoSecretBoxer::GetKeySize();
   scoped_ptr<uint8[]> key(new uint8[key_size]);
@@ skipping 318 matching lines @@
              nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       nullptr);
 }
 
 }  // namespace test
 }  // namespace net