Replace va_arg version of crypto_test_utils::Message with a more modern vector argument version.

net/quic/test_tools/crypto_test_utils.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/test_tools/crypto_test_utils.h"
 
 #include <memory>
 
 #include "crypto/openssl_util.h"
 #include "crypto/secure_hash.h"
@@ skipping 823 matching lines @@
   for (size_t i = 0; i < 4; i++) {
     tag >>= 8;
     if (i < len) {
       tag |= static_cast<uint32_t>(tagstr[i]) << 24;
     }
   }
 
   return tag;
 }
 
-CryptoHandshakeMessage Message(const char* message_tag, ...) {
-  va_list ap;
-  va_start(ap, message_tag);
+CryptoHandshakeMessage CreateCHLO(
+    std::vector<std::pair<string, string>> tags_and_values) {
+  return CreateCHLO(tags_and_values, -1);
+}
 
+CryptoHandshakeMessage CreateCHLO(
+    std::vector<std::pair<string, string>> tags_and_values,
+    int minimum_size_bytes) {
   CryptoHandshakeMessage msg;
-  msg.set_tag(ParseTag(message_tag));
+  msg.set_tag(MakeQuicTag('C', 'H', 'L', 'O'));
 
-  for (;;) {
-    const char* tagstr = va_arg(ap, const char*);
-    if (tagstr == nullptr) {
-      break;
-    }
+  if (minimum_size_bytes > 0) {
+    msg.set_minimum_size(minimum_size_bytes);
+  }
 
-    if (tagstr[0] == '$') {
-      // Special value.
-      const char* const special = tagstr + 1;
-      if (strcmp(special, "padding") == 0) {
-        const int min_bytes = va_arg(ap, int);
-        msg.set_minimum_size(min_bytes);
-      } else {
-        CHECK(false) << "Unknown special value: " << special;
-      }
+  for (const auto& tag_and_value : tags_and_values) {
+    const string& tag = tag_and_value.first;
+    const string& value = tag_and_value.second;
 
+    const QuicTag quic_tag = ParseTag(tag.c_str());
+
+    size_t value_len = value.length();
+    if (value_len > 0 && value[0] == '#') {
+      // This is ascii encoded hex.
+      string hex_value = QuicTextUtils::HexDecode(StringPiece(&value[1]));
+      msg.SetStringPiece(quic_tag, hex_value);
       continue;
     }
-
-    const QuicTag tag = ParseTag(tagstr);
-    const char* valuestr = va_arg(ap, const char*);
-
-    size_t len = strlen(valuestr);
-    if (len > 0 && valuestr[0] == '#') {
-      valuestr++;
-      len--;
-
-      CHECK_EQ(0u, len % 2);
-      std::unique_ptr<uint8_t[]> buf(new uint8_t[len / 2]);
-
-      for (size_t i = 0; i < len / 2; i++) {
-        uint8_t v = 0;
-        CHECK(HexChar(valuestr[i * 2], &v));
-        buf[i] = v << 4;
-        CHECK(HexChar(valuestr[i * 2 + 1], &v));
-        buf[i] |= v;
-      }
-
-      msg.SetStringPiece(
-          tag, StringPiece(reinterpret_cast<char*>(buf.get()), len / 2));
-      continue;
-    }
-
-    msg.SetStringPiece(tag, valuestr);
+    msg.SetStringPiece(quic_tag, value);
   }
 
   // The CryptoHandshakeMessage needs to be serialized and parsed to ensure
   // that any padding is included.
   std::unique_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   std::unique_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
-  va_end(ap);
   return *parsed;
 }
 
 ChannelIDSource* ChannelIDSourceForTesting() {
   return new TestChannelIDSource();
 }
 
 void MovePackets(PacketSavingConnection* source_conn,
                  size_t* inout_packet_index,
                  QuicCryptoStream* dest_stream,
@@ skipping 38 matching lines @@
     dest_stream->OnHandshakeMessage(message);
   }
   QuicConnectionPeer::SetCurrentPacket(dest_conn, StringPiece(nullptr, 0));
 }
 
 CryptoHandshakeMessage GenerateDefaultInchoateCHLO(
     const QuicClock* clock,
     QuicVersion version,
     QuicCryptoServerConfig* crypto_config) {
   // clang-format off
-  return Message(
-      "CHLO",
-      "PDMD", "X509",
-      "AEAD", "AESG",
-      "KEXS", "C255",
-      "PUBS", GenerateClientPublicValuesHex().c_str(),
-      "NONC", GenerateClientNonceHex(clock,
-                                                      crypto_config).c_str(),
-      "VER\0", QuicTagToString(
-          QuicVersionToQuicTag(version)).c_str(),
-      "$padding", static_cast<int>(kClientHelloMinimumSize),
-      nullptr);
+  return CreateCHLO(
+      {{"PDMD", "X509"},
+       {"AEAD", "AESG"},
+       {"KEXS", "C255"},
+       {"PUBS", GenerateClientPublicValuesHex().c_str()},
+       {"NONC", GenerateClientNonceHex(clock, crypto_config).c_str()},
+       {"VER\0", QuicTagToString(QuicVersionToQuicTag(version)).c_str()}},
+      kClientHelloMinimumSize);
   // clang-format on
 }
 
 string GenerateClientNonceHex(const QuicClock* clock,
                               QuicCryptoServerConfig* crypto_config) {
   net::QuicCryptoServerConfig::ConfigOptions old_config_options;
   net::QuicCryptoServerConfig::ConfigOptions new_config_options;
   old_config_options.id = "old-config-id";
   delete crypto_config->AddDefaultConfig(net::QuicRandom::GetInstance(), clock,
                                          old_config_options);
@@ skipping 33 matching lines @@
   FullChloGenerator generator(crypto_config, server_addr, client_addr, clock,
                               proof, compressed_certs_cache, out);
   crypto_config->ValidateClientHello(
       inchoate_chlo, client_addr.host(), server_addr, version, clock, proof,
       generator.GetValidateClientHelloCallback());
 }
 
 }  // namespace crypto_test_utils
 }  // namespace test
 }  // namespace net