Plumb the net::SSLInfo to the browser process when it's using the network service.

content/common/resource_messages.cc

Index: content/common/resource_messages.cc
diff --git a/content/common/resource_messages.cc b/content/common/resource_messages.cc
index 5062ca5ede08ecb5eb3b37ad271c550771e16f05..4f9d3320516d8b76e064cf6b4b98ea061a5d8455 100644
--- a/content/common/resource_messages.cc
+++ b/content/common/resource_messages.cc
@@ -46,6 +46,135 @@ void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log(
   l->append("<HttpResponseHeaders>");
 }
 
+namespace {
+void GetCertSize(base::PickleSizer* s, net::X509Certificate* cert) {
+  GetParamSize(s, !!cert);
+  if (cert) {
+    base::Pickle temp;
+    cert->Persist(&temp);

[yzshen1, 2017/04/13 20:43:50]

This means the certificate is serialized twice (once here and one one line 62).
I am not sure how is the perf impact of doing this. Is there a cheap way to
calculate an upper bound?

[jam, 2017/04/13 21:07:29]

Yes, that is how we implement GetCertSize for other classes as well (see above
in this file).

[dcheng, 2017/04/13 21:12:15]

We could try seeing if https://crbug.com/681080 is feasible as well, right?

[yzshen1, 2017/04/13 21:19:34]

Yeah. It will make even more sense if we support using multiple buffers to back
a single message, without copying the data when we need to grow the buffer(s).
There was a discussion for that feature, but I couldn't find the bug link at the
moment.

Anyway, that is out of scope of this review thread, I think. :)

[jam, 2017/04/13 23:04:22]

yep, agreed it's orthogonal :)

+    s->AddBytes(temp.payload_size());
+  }
+}
+
+void WriteCert(base::Pickle* m, net::X509Certificate* cert) {
+  WriteParam(m, !!cert);
+  if (cert)
+    cert->Persist(m);
+}
+
+bool ReadCert(base::PickleIterator* iter,
+              scoped_refptr<net::X509Certificate>* cert) {
+  bool has_cert = false;
+  if (!iter->ReadBool(&has_cert))
+    return false;
+  if (!has_cert)
+    return true;
+
+  *cert = net::X509Certificate::CreateFromPickle(
+      iter, net::X509Certificate::PICKLETYPE_CERTIFICATE_CHAIN_V3);
+  return !!cert->get();
+}
+
+}  // namespace
+
+void ParamTraits<net::SSLInfo>::GetSize(base::PickleSizer* s,
+                                        const param_type& p) {
+  GetCertSize(s, p.cert.get());

[dcheng, 2017/04/13 21:12:15]

I'm curious--do we want to be serializing the rest of this at all if is_valid()
is false?

[jam, 2017/04/13 23:04:22]

Good point, done

+  GetCertSize(s, p.unverified_cert.get());
+  GetParamSize(s, p.cert_status);
+  GetParamSize(s, p.security_bits);
+  GetParamSize(s, p.key_exchange_group);
+  GetParamSize(s, p.connection_status);
+  GetParamSize(s, p.is_issued_by_known_root);
+  GetParamSize(s, p.pkp_bypassed);
+  GetParamSize(s, p.client_cert_sent);
+  GetParamSize(s, p.channel_id_sent);
+  GetParamSize(s, p.token_binding_negotiated);
+  GetParamSize(s, p.token_binding_key_param);
+  GetParamSize(s, p.handshake_type);
+  GetParamSize(s, p.public_key_hashes);
+  GetParamSize(s, p.pinning_failure_log);
+  GetParamSize(s, p.signed_certificate_timestamps);
+  GetParamSize(s, p.ct_compliance_details_available);
+  GetParamSize(s, p.ct_ev_policy_compliance);
+  GetParamSize(s, p.ct_cert_policy_compliance);
+  GetParamSize(s, p.ocsp_result.response_status);
+  GetParamSize(s, p.ocsp_result.revocation_status);
+}
+
+void ParamTraits<net::SSLInfo>::Write(base::Pickle* m, const param_type& p) {
+  WriteCert(m, p.cert.get());
+  WriteCert(m, p.unverified_cert.get());
+  WriteParam(m, p.cert_status);
+  WriteParam(m, p.security_bits);
+  WriteParam(m, p.key_exchange_group);
+  WriteParam(m, p.connection_status);
+  WriteParam(m, p.is_issued_by_known_root);
+  WriteParam(m, p.pkp_bypassed);
+  WriteParam(m, p.client_cert_sent);
+  WriteParam(m, p.channel_id_sent);
+  WriteParam(m, p.token_binding_negotiated);
+  WriteParam(m, p.token_binding_key_param);
+  WriteParam(m, p.handshake_type);
+  WriteParam(m, p.public_key_hashes);
+  WriteParam(m, p.pinning_failure_log);
+  WriteParam(m, p.signed_certificate_timestamps);
+  WriteParam(m, p.ct_compliance_details_available);
+  WriteParam(m, p.ct_ev_policy_compliance);
+  WriteParam(m, p.ct_cert_policy_compliance);
+  WriteParam(m, p.ocsp_result.response_status);
+  WriteParam(m, p.ocsp_result.revocation_status);
+}
+
+bool ParamTraits<net::SSLInfo>::Read(const base::Pickle* m,
+                                     base::PickleIterator* iter,
+                                     param_type* r) {
+  return ReadCert(iter, &r->cert) &&
+         ReadCert(iter, &r->unverified_cert) &&
+         ReadParam(m, iter, &r->cert_status) &&
+         ReadParam(m, iter, &r->security_bits) &&
+         ReadParam(m, iter, &r->key_exchange_group) &&
+         ReadParam(m, iter, &r->connection_status) &&
+         ReadParam(m, iter, &r->is_issued_by_known_root) &&
+         ReadParam(m, iter, &r->pkp_bypassed) &&
+         ReadParam(m, iter, &r->client_cert_sent) &&
+         ReadParam(m, iter, &r->channel_id_sent) &&
+         ReadParam(m, iter, &r->token_binding_negotiated) &&
+         ReadParam(m, iter, &r->token_binding_key_param) &&
+         ReadParam(m, iter, &r->handshake_type) &&
+         ReadParam(m, iter, &r->public_key_hashes) &&
+         ReadParam(m, iter, &r->signed_certificate_timestamps) &&
+         ReadParam(m, iter, &r->ct_compliance_details_available) &&
+         ReadParam(m, iter, &r->ct_ev_policy_compliance) &&
+         ReadParam(m, iter, &r->ct_cert_policy_compliance) &&
+         ReadParam(m, iter, &r->ocsp_result.response_status) &&
+         ReadParam(m, iter, &r->ocsp_result.revocation_status);
+}
+
+void ParamTraits<net::SSLInfo>::Log(const param_type& p, std::string* l) {
+  l->append("<SSLInfo>");
+}
+
+void ParamTraits<net::HashValue>::GetSize(base::PickleSizer* s,
+                                          const param_type& p) {
+  GetParamSize(s, p.ToString());
+}
+
+void ParamTraits<net::HashValue>::Write(base::Pickle* m, const param_type& p) {
+  WriteParam(m, p.ToString());
+}
+
+bool ParamTraits<net::HashValue>::Read(const base::Pickle* m,
+                                       base::PickleIterator* iter,
+                                       param_type* r) {
+  std::string str;
+  return ReadParam(m, iter, &str) && r->FromString(str);
+}
+
+void ParamTraits<net::HashValue>::Log(const param_type& p, std::string* l) {
+  l->append("<HashValue>");
+}
+
 void ParamTraits<storage::DataElement>::GetSize(base::PickleSizer* s,
                                                 const param_type& p) {
   GetParamSize(s, static_cast<int>(p.type()));