Add a new QUIC platform API for text utilities.

net/quic/test_tools/crypto_test_utils_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/test_tools/crypto_test_utils.h"
 
 #include "net/quic/core/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/core/quic_utils.h"
+#include "net/quic/platform/api/quic_text_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 
@@ skipping 65 matching lines @@
     ShloVerifier* shlo_verifier_;
   };
 
   std::unique_ptr<ProcessClientHelloCallback> GetProcessClientHelloCallback() {
     return std::unique_ptr<ProcessClientHelloCallback>(
         new ProcessClientHelloCallback(this));
   }
 
   void ProcessClientHelloDone(std::unique_ptr<CryptoHandshakeMessage> message) {
     // Verify output is a SHLO.
-    EXPECT_EQ(message->tag(), kSHLO) << "Fail to pass validation. Get "
-                                     << message->DebugString();
+    EXPECT_EQ(message->tag(), kSHLO)
+        << "Fail to pass validation. Get " << message->DebugString();
   }
 
   QuicCryptoServerConfig* crypto_config_;
   QuicSocketAddress server_addr_;
   QuicSocketAddress client_addr_;
   const QuicClock* clock_;
   QuicReferenceCountedPointer<QuicSignedServerConfig> signed_config_;
   QuicCompressedCertsCache* compressed_certs_cache_;
 
   QuicReferenceCountedPointer<QuicCryptoNegotiatedParameters> params_;
@@ skipping 26 matching lines @@
   std::unique_ptr<CryptoHandshakeMessage> msg(
       crypto_config.AddConfig(std::move(primary_config), clock.WallNow()));
   StringPiece orbit;
   ASSERT_TRUE(msg->GetStringPiece(kORBT, &orbit));
   string nonce;
   CryptoUtils::GenerateNonce(
       clock.WallNow(), QuicRandom::GetInstance(),
       StringPiece(reinterpret_cast<const char*>(orbit.data()),
                   sizeof(orbit.size())),
       &nonce);
-  string nonce_hex = "#" + QuicUtils::HexEncode(nonce);
+  string nonce_hex = "#" + QuicTextUtils::HexEncode(nonce);
 
   char public_value[32];
   memset(public_value, 42, sizeof(public_value));
   string pub_hex =
-      "#" + QuicUtils::HexEncode(public_value, sizeof(public_value));
+      "#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value));
 
   QuicVersion version(AllSupportedVersions().front());
   // clang-format off
   CryptoHandshakeMessage inchoate_chlo = CryptoTestUtils::Message(
     "CHLO",
     "PDMD", "X509",
     "AEAD", "AESG",
     "KEXS", "C255",
     "COPT", "SREJ",
     "PUBS", pub_hex.c_str(),
     "NONC", nonce_hex.c_str(),
     "VER\0", QuicTagToString(QuicVersionToQuicTag(version)).c_str(),
     "$padding", static_cast<int>(kClientHelloMinimumSize),
     nullptr);
   // clang-format on
 
   CryptoTestUtils::GenerateFullCHLO(inchoate_chlo, &crypto_config, server_addr,
                                     client_addr, version, &clock, signed_config,
                                     &compressed_certs_cache, &full_chlo);
   // Verify that full_chlo can pass crypto_config's verification.
   ShloVerifier shlo_verifier(&crypto_config, server_addr, client_addr, &clock,
                              signed_config, &compressed_certs_cache);
   crypto_config.ValidateClientHello(
       full_chlo, client_addr.host(), server_addr, version, &clock,
       signed_config, shlo_verifier.GetValidateClientHelloCallback());
 }
 
 }  // namespace test
 }  // namespace net