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 |
- |