Remove stl_util's deletion functions from:

net/quic/core/crypto/quic_crypto_client_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_client_config.h"
 
 #include <memory>
 
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/quic/core/crypto/cert_compressor.h"
 #include "net/quic/core/crypto/chacha20_poly1305_encrypter.h"
 #include "net/quic/core/crypto/channel_id.h"
 #include "net/quic/core/crypto/common_cert_set.h"
 #include "net/quic/core/crypto/crypto_framer.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/curve25519_key_exchange.h"
@@ skipping 36 matching lines @@
 }  // namespace
 
 QuicCryptoClientConfig::QuicCryptoClientConfig(
     std::unique_ptr<ProofVerifier> proof_verifier)
     : proof_verifier_(std::move(proof_verifier)) {
   DCHECK(proof_verifier_.get());
   SetDefaults();
 }
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
-  base::STLDeleteValues(&cached_states_);
 }
 
 QuicCryptoClientConfig::CachedState::CachedState()
     : server_config_valid_(false),
       expiration_time_(QuicWallTime::Zero()),
       generation_counter_(0) {}
 
 QuicCryptoClientConfig::CachedState::~CachedState() {}
 
 bool QuicCryptoClientConfig::CachedState::IsComplete(QuicWallTime now) const {
@@ skipping 310 matching lines @@
 void QuicCryptoClientConfig::SetDefaults() {
   // Key exchange methods.
   kexs = {kC255, kP256};
 
   // Authenticated encryption algorithms. Prefer RFC 7539 ChaCha20 by default.
   aead = {kCC20, kAESG};
 }
 
 QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::LookupOrCreate(
     const QuicServerId& server_id) {
-  CachedStateMap::const_iterator it = cached_states_.find(server_id);
+  auto it = cached_states_.find(server_id);
   if (it != cached_states_.end()) {
-    return it->second;
+    return it->second.get();
   }
 
   CachedState* cached = new CachedState;
-  cached_states_.insert(std::make_pair(server_id, cached));
+  cached_states_.insert(std::make_pair(server_id, base::WrapUnique(cached)));
   bool cache_populated = PopulateFromCanonicalConfig(server_id, cached);
   UMA_HISTOGRAM_BOOLEAN(
       "Net.QuicCryptoClientConfig.PopulatedFromCanonicalConfig",
       cache_populated);
   return cached;
 }
 
 void QuicCryptoClientConfig::ClearCachedStates(const ServerIdFilter& filter) {
-  for (CachedStateMap::const_iterator it = cached_states_.begin();
-       it != cached_states_.end(); ++it) {
+  for (auto it = cached_states_.begin(); it != cached_states_.end(); ++it) {
     if (filter.Matches(it->first))
       it->second->Clear();
   }
 }
 
 void QuicCryptoClientConfig::FillInchoateClientHello(
     const QuicServerId& server_id,
     const QuicVersion preferred_version,
     const CachedState* cached,
     QuicRandom* rand,
@@ skipping 553 matching lines @@
                                 server_id.privacy_mode());
   if (!base::ContainsKey(canonical_server_map_, suffix_server_id)) {
     // This is the first host we've seen which matches the suffix, so make it
     // canonical.
     canonical_server_map_[suffix_server_id] = server_id;
     return false;
   }
 
   const QuicServerId& canonical_server_id =
       canonical_server_map_[suffix_server_id];
-  CachedState* canonical_state = cached_states_[canonical_server_id];
+  CachedState* canonical_state = cached_states_[canonical_server_id].get();
   if (!canonical_state->proof_valid()) {
     return false;
   }
 
   // Update canonical version to point at the "most recent" entry.
   canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
   return true;
 }
 
 }  // namespace net