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

content/common/resource_messages.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 "content/common/resource_messages.h"
 
 #include "net/base/load_timing_info.h"
 #include "net/http/http_response_headers.h"
 
 namespace IPC {
@@ skipping 28 matching lines @@
   if (has_object)
     *r = new net::HttpResponseHeaders(iter);
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log(
     const param_type& p, std::string* l) {
   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()));
   switch (p.type()) {
     case storage::DataElement::TYPE_BYTES: {
       s->AddData(static_cast<int>(p.length()));
       break;
     }
     case storage::DataElement::TYPE_BYTES_DESCRIPTION: {
       GetParamSize(s, p.length());
@@ skipping 421 matching lines @@
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Log(
     const param_type& p,
     std::string* l) {
   l->append("<SignedCertificateTimestamp>");
 }
 
 }  // namespace IPC