Add QuicLRUCache.

net/quic/core/crypto/quic_compressed_certs_cache.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/quic/core/crypto/quic_compressed_certs_cache.h"
 
 using std::string;
 
 namespace net {
 
@@ skipping 58 matching lines @@
 
 const string* QuicCompressedCertsCache::GetCompressedCert(
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
     const string& client_common_set_hashes,
     const string& client_cached_cert_hashes) {
   UncompressedCerts uncompressed_certs(chain, &client_common_set_hashes,
                                        &client_cached_cert_hashes);
 
   uint64_t key = ComputeUncompressedCertsHash(uncompressed_certs);
 
-  auto cached_it = certs_cache_.Get(key);
-
-  if (cached_it != certs_cache_.end()) {
-    const CachedCerts& cached_value = cached_it->second;
-    if (cached_value.MatchesUncompressedCerts(uncompressed_certs)) {
-      return cached_value.compressed_cert();
-    }
+  CachedCerts* cached_value = certs_cache_.Lookup(key);
+  if (cached_value != nullptr &&
+      cached_value->MatchesUncompressedCerts(uncompressed_certs)) {
+    return cached_value->compressed_cert();
   }
   return nullptr;
 }
 
 void QuicCompressedCertsCache::Insert(
     const QuicReferenceCountedPointer<ProofSource::Chain>& chain,
     const string& client_common_set_hashes,
     const string& client_cached_cert_hashes,
     const string& compressed_cert) {
   UncompressedCerts uncompressed_certs(chain, &client_common_set_hashes,
                                        &client_cached_cert_hashes);
 
   uint64_t key = ComputeUncompressedCertsHash(uncompressed_certs);
 
   // Insert one unit to the cache.
-  certs_cache_.Put(key, CachedCerts(uncompressed_certs, compressed_cert));
+  std::unique_ptr<CachedCerts> cached_certs(
+      new CachedCerts(uncompressed_certs, compressed_cert));
+  certs_cache_.Insert(key, std::move(cached_certs));
 }
 
 size_t QuicCompressedCertsCache::MaxSize() {
-  return certs_cache_.max_size();
+  return certs_cache_.MaxSize();
 }
 
 size_t QuicCompressedCertsCache::Size() {
-  return certs_cache_.size();
+  return certs_cache_.Size();
 }
 
 uint64_t QuicCompressedCertsCache::ComputeUncompressedCertsHash(
     const UncompressedCerts& uncompressed_certs) {
   uint64_t hash =
       std::hash<string>()(*uncompressed_certs.client_common_set_hashes);
   uint64_t h =
       std::hash<string>()(*uncompressed_certs.client_cached_cert_hashes);
   hash_combine(&hash, h);
 
   hash_combine(&hash,
                reinterpret_cast<uint64_t>(uncompressed_certs.chain.get()));
   return hash;
 }
 
 }  // namespace net