Improving and adding an in-memory MRU cache to DiskBasedCertCache.

net/http/disk_based_cert_cache.h

 // Copyright (c) 2014 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.
 
 #ifndef NET_HTTP_DISK_BASED_CERT_CACHE_H
 #define NET_HTTP_DISK_BASED_CERT_CACHE_H
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
+#include "base/containers/mru_cache.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/net_export.h"
 #include "net/cert/x509_certificate.h"
 
 namespace disk_cache {
 class Backend;
 }  // namespace disk_cache
 
 namespace net {
 
@@ skipping 21 matching lines @@
   // Stores |cert_handle| in the cache. If |cert_handle| is successfully stored,
   // |cb| will be called with the key. If |cb| is called with an empty
   // string, then |cert_handle| was not stored.
   void Set(const X509Certificate::OSCertHandle cert_handle,
            const SetCallback& cb);
 
  private:
   class ReadWorker;
   class WriteWorker;
 
+  // A functor used to free an OSCertHandle. Used by the MRUCertCache.
+  class CertFree {
+   public:
+    void operator()(X509Certificate::OSCertHandle cert_handle) {
+      X509Certificate::FreeOSCertHandle(cert_handle);
+    }
+  };
+
+  // An in-memory cache that is used to prevent redundant reads and writes
+  // to and from the disk cache.
+  class MRUCertCache : public base::MRUCacheBase<std::string,

[wtc, 2014/07/01 02:11:31]

Since MRUCertCache doesn't have any new method or constructor, I think it can be
just a typedef:

  typedef base::MRUCacheBase<std::string,
                             X509Certificate::OSCertHandle,
                             CertFree> MRUCertCache;

Does this work?

+                                                 X509Certificate::OSCertHandle,
+                                                 CertFree> {
+   private:
+    typedef base::MRUCacheBase<std::string,
+                               X509Certificate::OSCertHandle,
+                               CertFree> ParentType;
+
+   public:
+    // |max_size| is the maximum number of OSCertHandles to be stored
+    // at one time.
+    explicit MRUCertCache(typename ParentType::size_type max_size)
+        : ParentType(max_size) {}
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(MRUCertCache);
+  };
+
   // ReadWorkerMap and WriteWorkerMap map cache keys to their
   // corresponding Workers.
   typedef base::hash_map<std::string, ReadWorker*> ReadWorkerMap;
   typedef base::hash_map<std::string, WriteWorker*> WriteWorkerMap;
 
   // FinishedReadOperation and FinishedWriteOperation are used by callbacks
   // given to the workers to signal the DiskBasedCertCache they have completed
-  // their work.
-  void FinishedReadOperation(const std::string& key);
+  // their work. FinishedReadOperation also stores the retrieved OSCertHandle
+  // in |mru_cert_cache_|.
+  void FinishedReadOperation(const std::string& key,
+                             X509Certificate::OSCertHandle cert_handle);
   void FinishedWriteOperation(const std::string& key);
 
+  disk_cache::Backend* backend_;
+
   ReadWorkerMap read_worker_map_;
   WriteWorkerMap write_worker_map_;
+  MRUCertCache mru_cert_cache_;
 
-  disk_cache::Backend* backend_;
   base::WeakPtrFactory<DiskBasedCertCache> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(DiskBasedCertCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_DISK_BASED_CERT_CACHE_H