Add support for walking and modifying the CachingCertVerifier

net/cert/caching_cert_verifier.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/cert/caching_cert_verifier.h"
 
 #include "base/time/time.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_trust_anchor_provider.h"
 
 namespace net {
 
 namespace {
 
 // The maximum number of cache entries to use for the ExpiringCache.
 const unsigned kMaxCacheEntries = 256;
 
 // The number of seconds to cache entries.
 const unsigned kTTLSecs = 1800;  // 30 minutes.
 
 }  // namespace
 
+CachingCertVerifier::Iterator::Iterator(const CachingCertVerifier& verifier)
+    : iter_(nullptr) {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  iter_ = reinterpret_cast<void*>(new Iter(verifier.cache_));
+}
+
+CachingCertVerifier::Iterator::~Iterator() {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  Iter* it = reinterpret_cast<Iter*>(iter_);
+  delete it;
+}
+
+bool CachingCertVerifier::Iterator::HasNext() const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->HasNext();
+}
+
+void CachingCertVerifier::Iterator::Advance() {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  Iter* it = reinterpret_cast<Iter*>(iter_);
+  it->Advance();
+}
+
+const CertVerifier::RequestParams& CachingCertVerifier::Iterator::params()
+    const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->key();
+}
+
+int CachingCertVerifier::Iterator::error() const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->value().error;
+}
+
+const CertVerifyResult& CachingCertVerifier::Iterator::verify_result() const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->value().result;
+}
+
+base::Time CachingCertVerifier::Iterator::verification_time() const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->expiration().verification_time;
+}
+
+base::Time CachingCertVerifier::Iterator::expiration_time() const {
+  using Iter = CachingCertVerifier::CertVerificationCache::Iterator;
+  const Iter* it = reinterpret_cast<const Iter*>(iter_);
+  return it->expiration().expiration_time;
+}
+
 CachingCertVerifier::CachingCertVerifier(std::unique_ptr<CertVerifier> verifier)
     : verifier_(std::move(verifier)),
       trust_anchor_provider_(nullptr),
       cache_(kMaxCacheEntries),
       requests_(0u),
       cache_hits_(0u) {
   CertDatabase::GetInstance()->AddObserver(this);
 }
 
 CachingCertVerifier::~CachingCertVerifier() {
@@ skipping 46 matching lines @@
     AddResultToCache(new_params, start_time, *verify_result, result);
   }
 
   return result;
 }
 
 bool CachingCertVerifier::SupportsOCSPStapling() {
   return verifier_->SupportsOCSPStapling();
 }
 
+bool CachingCertVerifier::AddEntry(const RequestParams& params,
+                                   int error,
+                                   const CertVerifyResult& verify_result,
+                                   base::Time verification_time) {
+  // If the cache is full, don't bother.
+  if (cache_.size() == cache_.max_entries())
+    return false;
+
+  // If there is an existing entry, don't bother updating it.
+  const CertVerificationCache::value_type* entry =
+      cache_.Get(params, CacheValidityPeriod(base::Time::Now()));
+  if (entry)
+    return false;
+
+  // Otherwise, go and add it.
+  AddResultToCache(params, verification_time, verify_result, error);
+  return true;
+}
+
 CachingCertVerifier::CachedResult::CachedResult() : error(ERR_FAILED) {}
 
 CachingCertVerifier::CachedResult::~CachedResult() {}
 
 CachingCertVerifier::CacheValidityPeriod::CacheValidityPeriod(base::Time now)
     : verification_time(now), expiration_time(now) {}
 
 CachingCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     base::Time now,
     base::Time expiration)
@@ skipping 88 matching lines @@
 
 void CachingCertVerifier::ClearCache() {
   cache_.Clear();
 }
 
 size_t CachingCertVerifier::GetCacheSize() const {
   return cache_.size();
 }
 
 }  // namespace net