Cert - protobufs to serialize and deserialize CertVerifierCache.

net/cert/multi_threaded_cert_verifier.cc

 // Copyright (c) 2012 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/multi_threaded_cert_verifier.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 101 matching lines @@
   }
   results->Set("public_key_hashes", std::move(hashes));
 
   return std::move(results);
 }
 
 }  // namespace
 
 MultiThreadedCertVerifier::CachedResult::CachedResult() : error(ERR_FAILED) {}
 
+MultiThreadedCertVerifier::CachedResult::CachedResult(
+    int error_arg,
+    CertVerifyResult result_arg)
+    : error(error_arg) {
+  result.CopyFrom(result_arg);
+}
+
 MultiThreadedCertVerifier::CachedResult::~CachedResult() {}
 
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now)
     : verification_time(now),
       expiration_time(now) {
 }
 
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now,
@@ skipping 344 matching lines @@
   std::unique_ptr<CertVerifierRequest> request =
       job->CreateRequest(callback, verify_result, net_log);
   *out_req = std::move(request);
   return ERR_IO_PENDING;
 }
 
 bool MultiThreadedCertVerifier::SupportsOCSPStapling() {
   return verify_proc_->SupportsOCSPStapling();
 }
 
+bool MultiThreadedCertVerifier::AddCertResult(
+    std::string& hostname,
+    int flags,
+    std::vector<SHA1HashValue>& hash_values,
+    base::Time start_time,
+    int error,
+    const CertVerifyResult& result,
+    base::Time verification_time,
+    base::Time expiration_time) {
+  // If cache is already full, then don't replace the current entries.
+  if (cache_.size() >= kMaxCacheEntries) {
+    DVLOG(1) << "Cache is full";
+    return false;
+  }
+  base::Time now = base::Time::Now();
+  if (expiration_time < now) {
+    DVLOG(1) << "Cache entry expired for: " << hostname;
+    return false;
+  }
+  if (verification_time > expiration_time || verification_time > now) {
+    DVLOG(1) << "Invalid verification_time for " << hostname;
+    return false;
+  }
+
+  // Don't overwrite existing entry.
+  RequestParams key(hostname, flags, hash_values, start_time);
+  CacheValidityPeriod expiration(now);
+  if (cache_.Get(key, expiration)) {
+    DVLOG(1) << "Already exists in the cache for " << key.hostname;
+    return false;
+  }
+
+  // Add a new entry.
+  CachedResult value(error, result);
+  cache_.Put(key, value, CacheValidityPeriod(verification_time),
+             CacheValidityPeriod(verification_time, expiration_time));
+  return true;
+}
+
 MultiThreadedCertVerifier::RequestParams::RequestParams(
     const SHA1HashValue& cert_fingerprint_arg,
     const SHA1HashValue& ca_fingerprint_arg,
     const std::string& hostname_arg,
     const std::string& ocsp_response_arg,
     int flags_arg,
     const CertificateList& additional_trust_anchors)
     : hostname(hostname_arg), flags(flags_arg), start_time(base::Time::Now()) {
   hash_values.reserve(3 + additional_trust_anchors.size());
   SHA1HashValue ocsp_hash;
   base::SHA1HashBytes(
       reinterpret_cast<const unsigned char*>(ocsp_response_arg.data()),
       ocsp_response_arg.size(), ocsp_hash.data);
   hash_values.push_back(ocsp_hash);
   hash_values.push_back(cert_fingerprint_arg);
   hash_values.push_back(ca_fingerprint_arg);
   for (size_t i = 0; i < additional_trust_anchors.size(); ++i)
     hash_values.push_back(additional_trust_anchors[i]->fingerprint());
 }
 
 MultiThreadedCertVerifier::RequestParams::RequestParams(
     const RequestParams& other) = default;
 
+MultiThreadedCertVerifier::RequestParams::RequestParams(
+    std::string& hostname_arg,
+    int flags_arg,
+    std::vector<SHA1HashValue>& hash_values_arg,
+    base::Time start_time_arg) {
+  hostname = hostname_arg;
+  flags = flags_arg;
+  hash_values.swap(hash_values_arg);
+  start_time = start_time_arg;
+}
+
 MultiThreadedCertVerifier::RequestParams::~RequestParams() {}
 
 bool MultiThreadedCertVerifier::RequestParams::operator<(
     const RequestParams& other) const {
   // |flags| is compared before |cert_fingerprint|, |ca_fingerprint|,
   // |hostname|, and |ocsp_response|, under assumption that integer comparisons
   // are faster than memory and string comparisons.
   if (flags != other.flags)
     return flags < other.flags;
   if (hostname != other.hostname)
@@ skipping 70 matching lines @@
 
   // The JobSet is kept in sorted order so items can be found using binary
   // search.
   auto it = std::lower_bound(inflight_.begin(), inflight_.end(), key,
                              JobToRequestParamsComparator());
   if (it != inflight_.end() && !(key < (*it)->key()))
     return *it;
   return nullptr;
 }
 
+CertVerifierCacheIterator::CertVerifierCacheIterator(
+    const MultiThreadedCertVerifier& verifier)
+    : iterator_(verifier.cache_) {}
+
+CertVerifierCacheIterator::~CertVerifierCacheIterator() {}
+
 }  // namespace net