Add a new QUIC platform API for text utilities.

net/tools/quic/stateless_rejector_test.cc

 // Copyright 2016 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/tools/quic/stateless_rejector.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
 #include "net/quic/core/crypto/crypto_handshake_message.h"
 #include "net/quic/core/crypto/proof_source.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_str_cat.h"
+#include "net/quic/platform/api/quic_text_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_crypto_server_config_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using std::string;
 
 namespace net {
 namespace test {
 namespace {
 
@@ skipping 67 matching lines @@
     FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support =
         GetParam().flags == ENABLED || GetParam().flags == CHEAP_DISABLED;
     FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects =
         GetParam().flags == ENABLED || GetParam().flags == STATELESS_DISABLED;
 
     // Add a new primary config.
     std::unique_ptr<CryptoHandshakeMessage> msg(config_.AddDefaultConfig(
         QuicRandom::GetInstance(), &clock_, config_options_));
 
     // Save the server config.
-    scid_hex_ = "#" + QuicUtils::HexEncode(config_peer_.GetPrimaryConfig()->id);
+    scid_hex_ =
+        "#" + QuicTextUtils::HexEncode(config_peer_.GetPrimaryConfig()->id);
 
     // Encode the QUIC version.
     ver_hex_ = QuicTagToString(QuicVersionToQuicTag(GetParam().version));
 
     // Generate a public value.
     char public_value[32];
     memset(public_value, 42, sizeof(public_value));
-    pubs_hex_ = "#" + QuicUtils::HexEncode(public_value, sizeof(public_value));
+    pubs_hex_ =
+        "#" + QuicTextUtils::HexEncode(public_value, sizeof(public_value));
 
     // Generate a client nonce.
     string nonce;
     CryptoUtils::GenerateNonce(
         clock_.WallNow(), QuicRandom::GetInstance(),
         StringPiece(
             reinterpret_cast<char*>(config_peer_.GetPrimaryConfig()->orbit),
             kOrbitSize),
         &nonce);
-    nonc_hex_ = "#" + QuicUtils::HexEncode(nonce);
+    nonc_hex_ = "#" + QuicTextUtils::HexEncode(nonce);
 
     // Generate a source address token.
     SourceAddressTokens previous_tokens;
     QuicIpAddress ip = QuicIpAddress::Loopback4();
     MockRandom rand;
     string stk = config_peer_.NewSourceAddressToken(
         config_peer_.GetPrimaryConfig()->id, previous_tokens, ip, &rand,
         clock_.WallNow(), nullptr);
-    stk_hex_ = "#" + QuicUtils::HexEncode(stk);
+    stk_hex_ = "#" + QuicTextUtils::HexEncode(stk);
   }
 
  protected:
   class ProcessDoneCallback : public StatelessRejector::ProcessDoneCallback {
    public:
     explicit ProcessDoneCallback(StatelessRejectorTest* test) : test_(test) {}
     void Run(std::unique_ptr<StatelessRejector> rejector) override {
       test_->rejector_ = std::move(rejector);
     }
 
@@ skipping 105 matching lines @@
   EXPECT_EQ(QUIC_NO_ERROR,
             reply.GetTaglist(kRREJ, &reject_reasons, &num_reject_reasons));
   EXPECT_EQ(1u, num_reject_reasons);
   EXPECT_EQ(INVALID_EXPECTED_LEAF_CERTIFICATE,
             static_cast<HandshakeFailureReason>(reject_reasons[0]));
 }
 
 TEST_P(StatelessRejectorTest, AcceptChlo) {
   const uint64_t xlct = CryptoTestUtils::LeafCertHashForTesting();
   const string xlct_hex =
-      "#" +
-      QuicUtils::HexEncode(reinterpret_cast<const char*>(&xlct), sizeof(xlct));
+      "#" + QuicTextUtils::HexEncode(reinterpret_cast<const char*>(&xlct),
+                                     sizeof(xlct));
   // clang-format off
   const CryptoHandshakeMessage client_hello = CryptoTestUtils::Message(
       "CHLO",
       "PDMD", "X509",
       "AEAD", "AESG",
       "KEXS", "C255",
       "COPT", "SREJ",
       "SCID", scid_hex_.c_str(),
       "PUBS", pubs_hex_.c_str(),
       "NONC", nonc_hex_.c_str(),
@@ skipping 15 matching lines @@
   ASSERT_EQ(StatelessRejector::UNKNOWN, rejector_->state());
   StatelessRejector::Process(std::move(rejector_),
                              base::MakeUnique<ProcessDoneCallback>(this));
 
   EXPECT_EQ(StatelessRejector::ACCEPTED, rejector_->state());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net