Pickle (serialize and deserialize) MultiThreadedCertVerifier's |cache_|

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 <utility>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
 
   return std::move(results);
 }
 
 }  // namespace
 
 MultiThreadedCertVerifier::CachedResult::CachedResult() : error(ERR_FAILED) {}
 
 MultiThreadedCertVerifier::CachedResult::~CachedResult() {}
 
+bool MultiThreadedCertVerifier::CachedResult::Persist(
+    base::Pickle* pickle) const {
+  return pickle->WriteInt(error) && result.Persist(pickle);
+}
+
+// static
+bool MultiThreadedCertVerifier::CachedResult::CreateFromPickle(
+    base::PickleIterator* iter,
+    CachedResult* cached_result) {
+  return iter->ReadInt(&cached_result->error) &&
+         CertVerifyResult::CreateFromPickle(iter, &cached_result->result);
+}
+
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now)
     : verification_time(now),
       expiration_time(now) {
 }
 
 MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
     const base::Time& now,
     const base::Time& expiration)
     : verification_time(now),
       expiration_time(expiration) {
 }
 
+bool MultiThreadedCertVerifier::CacheValidityPeriod::Persist(
+    base::Pickle* pickle) const {
+  return pickle->WriteInt64(verification_time.ToInternalValue()) &&
+         pickle->WriteInt64(expiration_time.ToInternalValue());
+}
+
+// static
+bool MultiThreadedCertVerifier::CacheValidityPeriod::CreateFromPickle(
+    base::PickleIterator* iter,
+    CacheValidityPeriod* valid_period) {
+  int64_t verification;
+  int64_t expiration;
+  if ((!iter->ReadInt64(&verification)) || (!iter->ReadInt64(&expiration)))
+    return false;
+  valid_period->verification_time = base::Time::FromInternalValue(verification);
+  valid_period->expiration_time = base::Time::FromInternalValue(expiration);
+  return true;
+}
+
 bool MultiThreadedCertVerifier::CacheExpirationFunctor::operator()(
     const CacheValidityPeriod& now,
     const CacheValidityPeriod& expiration) const {
   // Ensure this functor is being used for expiration only, and not strict
   // weak ordering/sorting. |now| should only ever contain a single
   // base::Time.
   // Note: DCHECK_EQ is not used due to operator<< overloading requirements.
   DCHECK(now.verification_time == now.expiration_time);
 
   // |now| contains only a single time (verification_time), while |expiration|
@@ skipping 349 matching lines @@
   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() {}
+
 MultiThreadedCertVerifier::RequestParams::~RequestParams() {}
 
+bool MultiThreadedCertVerifier::RequestParams::Persist(
+    base::Pickle* pickle) const {
+  if (!pickle->WriteString(hostname) || !pickle->WriteInt(flags) ||
+      !pickle->WriteInt64(start_time.ToInternalValue()) ||
+      !pickle->WriteUInt64(hash_values.size())) {
+    return false;
+  }
+  for (const SHA1HashValue& value : hash_values) {
+    if (!value.Persist(pickle))
+      return false;
+  }
+  return true;
+}
+
+// static
+bool MultiThreadedCertVerifier::RequestParams::CreateFromPickle(
+    base::PickleIterator* iter,
+    MultiThreadedCertVerifier::RequestParams* request_param) {
+  int64_t start_time;
+  uint64_t hash_values_size;
+  if (!iter->ReadString(&request_param->hostname) ||
+      !iter->ReadInt(&request_param->flags) || !iter->ReadInt64(&start_time) ||
+      !iter->ReadUInt64(&hash_values_size)) {
+    return false;
+  }
+  request_param->start_time = base::Time::FromInternalValue(start_time);
+
+  request_param->hash_values.resize(hash_values_size);
+  for (uint64_t index = 0u; index < hash_values_size; ++index) {
+    if (!SHA1HashValue::CreateFromPickle(iter,
+                                         &request_param->hash_values[index]))
+      return false;
+  }
+  return true;
+}
+
 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)
     return hostname < other.hostname;
   return std::lexicographical_compare(
@@ skipping 34 matching lines @@
   // was corrected after validation, if the cache validity period was
   // computed at the end of validation, it would continue to serve an
   // invalid result for kTTLSecs.
   const base::Time start_time = key.start_time;
   cache_.Put(
       key, result, CacheValidityPeriod(start_time),
       CacheValidityPeriod(start_time,
                           start_time + base::TimeDelta::FromSeconds(kTTLSecs)));
 }
 
+bool MultiThreadedCertVerifier::SerializeCache(base::Pickle* pickle) {
+  if (!pickle->WriteUInt64(cache_.size()))
+    return false;
+  for (CertVerifierCache::Iterator it(cache_); it.HasNext(); it.Advance()) {
+    const RequestParams& key = it.key();
+    const CachedResult& result = it.value();
+    const CacheValidityPeriod& expiration = it.expiration();
+    if (!key.Persist(pickle) || !result.Persist(pickle) ||
+        !expiration.Persist(pickle)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// static
+bool MultiThreadedCertVerifier::CreateFromPickle(
+    base::PickleIterator* iter,
+    MultiThreadedCertVerifier* cert_verifier) {
+  uint64_t cache_size;
+  if (!iter->ReadUInt64(&cache_size) || cache_size > kMaxCacheEntries)
+    return false;
+  for (uint64_t index = 0u; index < cache_size; ++index) {
+    RequestParams key;
+    CachedResult result;
+    CacheValidityPeriod expiration(base::Time::Now());
+    if ((!MultiThreadedCertVerifier::RequestParams::CreateFromPickle(iter,
+                                                                     &key)) ||
+        (!MultiThreadedCertVerifier::CachedResult::CreateFromPickle(iter,
+                                                                    &result)) ||
+        (!MultiThreadedCertVerifier::CacheValidityPeriod::CreateFromPickle(
+            iter, &expiration))) {
+      return false;
+    }
+    cert_verifier->cache_.Put(key, result, CacheValidityPeriod(key.start_time),
+                              expiration);
+  }
+  return true;
+}
+
 scoped_ptr<CertVerifierJob> MultiThreadedCertVerifier::RemoveJob(
     CertVerifierJob* job) {
   DCHECK(CalledOnValidThread());
   bool erased_job = inflight_.erase(job) == 1;
   DCHECK(erased_job);
   return make_scoped_ptr(job);
 }
 
 void MultiThreadedCertVerifier::OnCACertChanged(
     const X509Certificate* cert) {
@@ skipping 15 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;
 }
 
 }  // namespace net
-