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

net/cert/multi_threaded_cert_verifier.cc

Index: net/cert/multi_threaded_cert_verifier.cc
diff --git a/net/cert/multi_threaded_cert_verifier.cc b/net/cert/multi_threaded_cert_verifier.cc
index 714b291b2bb0ba10e7b815dea899243b0dbaf236..70ecde89f48462b6380fee03f1c41bc9b00a8932 100644
--- a/net/cert/multi_threaded_cert_verifier.cc
+++ b/net/cert/multi_threaded_cert_verifier.cc
@@ -118,6 +118,19 @@ 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),
@@ -131,6 +144,25 @@ MultiThreadedCertVerifier::CacheValidityPeriod::CacheValidityPeriod(
       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 {
@@ -500,8 +532,46 @@ MultiThreadedCertVerifier::RequestParams::RequestParams(
 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|,
@@ -556,6 +626,46 @@ void MultiThreadedCertVerifier::SaveResultToCache(const RequestParams& key,
                           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());
@@ -591,4 +701,3 @@ CertVerifierJob* MultiThreadedCertVerifier::FindJob(const RequestParams& key) {
 }
 
 }  // namespace net
-