Add a new QUIC platform API for text utilities.

net/quic/core/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/core/crypto/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 19 matching lines @@
 #include "net/quic/core/crypto/quic_encrypter.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/proto/source_address_token.pb.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_socket_address_coder.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_clock.h"
 #include "net/quic/platform/api/quic_reference_counted.h"
+#include "net/quic/platform/api/quic_text_utils.h"
 
 using base::StringPiece;
 using crypto::SecureHash;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // kMultiplier is the multiple of the CHLO message size that a REJ message
@@ skipping 257 matching lines @@
   if (!config.get()) {
     LOG(WARNING) << "Failed to parse server config message";
     return nullptr;
   }
 
   {
     QuicWriterMutexLock locked(&configs_lock_);
     if (configs_.find(config->id) != configs_.end()) {
       LOG(WARNING) << "Failed to add config because another with the same "
                       "server config id already exists: "
-                   << QuicUtils::HexEncode(config->id);
+                   << QuicTextUtils::HexEncode(config->id);
       return nullptr;
     }
 
     configs_[config->id] = config;
     SelectNewPrimaryConfig(now);
     DCHECK(primary_config_.get());
     DCHECK_EQ(configs_.find(primary_config_->id)->second.get(),
               primary_config_.get());
   }
 
@@ skipping 36 matching lines @@
     QuicWriterMutexLock locked(&configs_lock_);
     ConfigMap new_configs;
 
     for (std::vector<QuicReferenceCountedPointer<Config>>::const_iterator i =
              parsed_configs.begin();
          i != parsed_configs.end(); ++i) {
       QuicReferenceCountedPointer<Config> config = *i;
 
       ConfigMap::iterator it = configs_.find(config->id);
       if (it != configs_.end()) {
-        VLOG(1) << "Keeping scid: " << QuicUtils::HexEncode(config->id)
+        VLOG(1) << "Keeping scid: " << QuicTextUtils::HexEncode(config->id)
                 << " orbit: "
-                << QuicUtils::HexEncode(
+                << QuicTextUtils::HexEncode(
                        reinterpret_cast<const char*>(config->orbit), kOrbitSize)
                 << " new primary_time " << config->primary_time.ToUNIXSeconds()
                 << " old primary_time "
                 << it->second->primary_time.ToUNIXSeconds() << " new priority "
                 << config->priority << " old priority " << it->second->priority;
         // Update primary_time and priority.
         it->second->primary_time = config->primary_time;
         it->second->priority = config->priority;
         new_configs.insert(*it);
       } else {
-        VLOG(1) << "Adding scid: " << QuicUtils::HexEncode(config->id)
+        VLOG(1) << "Adding scid: " << QuicTextUtils::HexEncode(config->id)
                 << " orbit: "
-                << QuicUtils::HexEncode(
+                << QuicTextUtils::HexEncode(
                        reinterpret_cast<const char*>(config->orbit), kOrbitSize)
                 << " primary_time " << config->primary_time.ToUNIXSeconds()
                 << " priority " << config->priority;
         new_configs.insert(std::make_pair(config->id, config));
       }
     }
 
     configs_.swap(new_configs);
     SelectNewPrimaryConfig(now);
     DCHECK(primary_config_.get());
@@ skipping 690 matching lines @@
     } else {
       next_config_promotion_time_ = config->primary_time;
     }
 
     if (primary_config_) {
       primary_config_->is_primary = false;
     }
     primary_config_ = new_primary;
     new_primary->is_primary = true;
     DVLOG(1) << "New primary config.  orbit: "
-             << QuicUtils::HexEncode(
+             << QuicTextUtils::HexEncode(
                     reinterpret_cast<const char*>(primary_config_->orbit),
                     kOrbitSize);
     if (primary_config_changed_cb_.get() != nullptr) {
       primary_config_changed_cb_->Run(primary_config_->id);
     }
 
     return;
   }
 
   // All config's primary times are in the past. We should make the most recent
   // and highest priority candidate primary.
   QuicReferenceCountedPointer<Config> new_primary = best_candidate;
   if (primary_config_) {
     primary_config_->is_primary = false;
   }
   primary_config_ = new_primary;
   new_primary->is_primary = true;
   DVLOG(1) << "New primary config.  orbit: "
-           << QuicUtils::HexEncode(
+           << QuicTextUtils::HexEncode(
                   reinterpret_cast<const char*>(primary_config_->orbit),
                   kOrbitSize)
-           << " scid: " << QuicUtils::HexEncode(primary_config_->id);
+           << " scid: " << QuicTextUtils::HexEncode(primary_config_->id);
   next_config_promotion_time_ = QuicWallTime::Zero();
   if (primary_config_changed_cb_.get() != nullptr) {
     primary_config_changed_cb_->Run(primary_config_->id);
   }
 }
 
 class QuicCryptoServerConfig::EvaluateClientHelloCallback
     : public ProofSource::Callback {
  public:
   EvaluateClientHelloCallback(
@@ skipping 891 matching lines @@
       expiry_time(QuicWallTime::Zero()),
       priority(0),
       source_address_token_boxer(nullptr) {}
 
 QuicCryptoServerConfig::Config::~Config() {}
 
 QuicSignedServerConfig::QuicSignedServerConfig() {}
 QuicSignedServerConfig::~QuicSignedServerConfig() {}
 
 }  // namespace net