OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/common/resource_messages.h" | 5 #include "content/common/resource_messages.h" |
6 | 6 |
7 #include "net/base/load_timing_info.h" | 7 #include "net/base/load_timing_info.h" |
8 #include "net/http/http_response_headers.h" | 8 #include "net/http/http_response_headers.h" |
9 | 9 |
10 namespace IPC { | 10 namespace IPC { |
(...skipping 28 matching lines...) Expand all Loading... |
39 if (has_object) | 39 if (has_object) |
40 *r = new net::HttpResponseHeaders(iter); | 40 *r = new net::HttpResponseHeaders(iter); |
41 return true; | 41 return true; |
42 } | 42 } |
43 | 43 |
44 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log( | 44 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log( |
45 const param_type& p, std::string* l) { | 45 const param_type& p, std::string* l) { |
46 l->append("<HttpResponseHeaders>"); | 46 l->append("<HttpResponseHeaders>"); |
47 } | 47 } |
48 | 48 |
| 49 namespace { |
| 50 void GetCertSize(base::PickleSizer* s, net::X509Certificate* cert) { |
| 51 base::Pickle temp; |
| 52 cert->Persist(&temp); |
| 53 s->AddBytes(temp.payload_size()); |
| 54 } |
| 55 |
| 56 void WriteCert(base::Pickle* m, net::X509Certificate* cert) { |
| 57 cert->Persist(m); |
| 58 } |
| 59 |
| 60 bool ReadCert(base::PickleIterator* iter, |
| 61 scoped_refptr<net::X509Certificate>* cert) { |
| 62 *cert = net::X509Certificate::CreateFromPickle( |
| 63 iter, net::X509Certificate::PICKLETYPE_CERTIFICATE_CHAIN_V3); |
| 64 return !!cert->get(); |
| 65 } |
| 66 |
| 67 } // namespace |
| 68 |
| 69 void ParamTraits<net::SSLInfo>::GetSize(base::PickleSizer* s, |
| 70 const param_type& p) { |
| 71 GetParamSize(s, p.is_valid()); |
| 72 if (!p.is_valid()) |
| 73 return; |
| 74 GetCertSize(s, p.cert.get()); |
| 75 GetCertSize(s, p.unverified_cert.get()); |
| 76 GetParamSize(s, p.cert_status); |
| 77 GetParamSize(s, p.security_bits); |
| 78 GetParamSize(s, p.key_exchange_group); |
| 79 GetParamSize(s, p.connection_status); |
| 80 GetParamSize(s, p.is_issued_by_known_root); |
| 81 GetParamSize(s, p.pkp_bypassed); |
| 82 GetParamSize(s, p.client_cert_sent); |
| 83 GetParamSize(s, p.channel_id_sent); |
| 84 GetParamSize(s, p.token_binding_negotiated); |
| 85 GetParamSize(s, p.token_binding_key_param); |
| 86 GetParamSize(s, p.handshake_type); |
| 87 GetParamSize(s, p.public_key_hashes); |
| 88 GetParamSize(s, p.pinning_failure_log); |
| 89 GetParamSize(s, p.signed_certificate_timestamps); |
| 90 GetParamSize(s, p.ct_compliance_details_available); |
| 91 GetParamSize(s, p.ct_ev_policy_compliance); |
| 92 GetParamSize(s, p.ct_cert_policy_compliance); |
| 93 GetParamSize(s, p.ocsp_result.response_status); |
| 94 GetParamSize(s, p.ocsp_result.revocation_status); |
| 95 } |
| 96 |
| 97 void ParamTraits<net::SSLInfo>::Write(base::Pickle* m, const param_type& p) { |
| 98 WriteParam(m, p.is_valid()); |
| 99 if (!p.is_valid()) |
| 100 return; |
| 101 WriteCert(m, p.cert.get()); |
| 102 WriteCert(m, p.unverified_cert.get()); |
| 103 WriteParam(m, p.cert_status); |
| 104 WriteParam(m, p.security_bits); |
| 105 WriteParam(m, p.key_exchange_group); |
| 106 WriteParam(m, p.connection_status); |
| 107 WriteParam(m, p.is_issued_by_known_root); |
| 108 WriteParam(m, p.pkp_bypassed); |
| 109 WriteParam(m, p.client_cert_sent); |
| 110 WriteParam(m, p.channel_id_sent); |
| 111 WriteParam(m, p.token_binding_negotiated); |
| 112 WriteParam(m, p.token_binding_key_param); |
| 113 WriteParam(m, p.handshake_type); |
| 114 WriteParam(m, p.public_key_hashes); |
| 115 WriteParam(m, p.pinning_failure_log); |
| 116 WriteParam(m, p.signed_certificate_timestamps); |
| 117 WriteParam(m, p.ct_compliance_details_available); |
| 118 WriteParam(m, p.ct_ev_policy_compliance); |
| 119 WriteParam(m, p.ct_cert_policy_compliance); |
| 120 WriteParam(m, p.ocsp_result.response_status); |
| 121 WriteParam(m, p.ocsp_result.revocation_status); |
| 122 } |
| 123 |
| 124 bool ParamTraits<net::SSLInfo>::Read(const base::Pickle* m, |
| 125 base::PickleIterator* iter, |
| 126 param_type* r) { |
| 127 bool is_valid = false; |
| 128 if (!ReadParam(m, iter, &is_valid)) |
| 129 return false; |
| 130 if (!is_valid) |
| 131 return true; |
| 132 return ReadCert(iter, &r->cert) && |
| 133 ReadCert(iter, &r->unverified_cert) && |
| 134 ReadParam(m, iter, &r->cert_status) && |
| 135 ReadParam(m, iter, &r->security_bits) && |
| 136 ReadParam(m, iter, &r->key_exchange_group) && |
| 137 ReadParam(m, iter, &r->connection_status) && |
| 138 ReadParam(m, iter, &r->is_issued_by_known_root) && |
| 139 ReadParam(m, iter, &r->pkp_bypassed) && |
| 140 ReadParam(m, iter, &r->client_cert_sent) && |
| 141 ReadParam(m, iter, &r->channel_id_sent) && |
| 142 ReadParam(m, iter, &r->token_binding_negotiated) && |
| 143 ReadParam(m, iter, &r->token_binding_key_param) && |
| 144 ReadParam(m, iter, &r->handshake_type) && |
| 145 ReadParam(m, iter, &r->public_key_hashes) && |
| 146 ReadParam(m, iter, &r->pinning_failure_log) && |
| 147 ReadParam(m, iter, &r->signed_certificate_timestamps) && |
| 148 ReadParam(m, iter, &r->ct_compliance_details_available) && |
| 149 ReadParam(m, iter, &r->ct_ev_policy_compliance) && |
| 150 ReadParam(m, iter, &r->ct_cert_policy_compliance) && |
| 151 ReadParam(m, iter, &r->ocsp_result.response_status) && |
| 152 ReadParam(m, iter, &r->ocsp_result.revocation_status); |
| 153 } |
| 154 |
| 155 void ParamTraits<net::SSLInfo>::Log(const param_type& p, std::string* l) { |
| 156 l->append("<SSLInfo>"); |
| 157 } |
| 158 |
| 159 void ParamTraits<net::HashValue>::GetSize(base::PickleSizer* s, |
| 160 const param_type& p) { |
| 161 GetParamSize(s, p.ToString()); |
| 162 } |
| 163 |
| 164 void ParamTraits<net::HashValue>::Write(base::Pickle* m, const param_type& p) { |
| 165 WriteParam(m, p.ToString()); |
| 166 } |
| 167 |
| 168 bool ParamTraits<net::HashValue>::Read(const base::Pickle* m, |
| 169 base::PickleIterator* iter, |
| 170 param_type* r) { |
| 171 std::string str; |
| 172 return ReadParam(m, iter, &str) && r->FromString(str); |
| 173 } |
| 174 |
| 175 void ParamTraits<net::HashValue>::Log(const param_type& p, std::string* l) { |
| 176 l->append("<HashValue>"); |
| 177 } |
| 178 |
49 void ParamTraits<storage::DataElement>::GetSize(base::PickleSizer* s, | 179 void ParamTraits<storage::DataElement>::GetSize(base::PickleSizer* s, |
50 const param_type& p) { | 180 const param_type& p) { |
51 GetParamSize(s, static_cast<int>(p.type())); | 181 GetParamSize(s, static_cast<int>(p.type())); |
52 switch (p.type()) { | 182 switch (p.type()) { |
53 case storage::DataElement::TYPE_BYTES: { | 183 case storage::DataElement::TYPE_BYTES: { |
54 s->AddData(static_cast<int>(p.length())); | 184 s->AddData(static_cast<int>(p.length())); |
55 break; | 185 break; |
56 } | 186 } |
57 case storage::DataElement::TYPE_BYTES_DESCRIPTION: { | 187 case storage::DataElement::TYPE_BYTES_DESCRIPTION: { |
58 GetParamSize(s, p.length()); | 188 GetParamSize(s, p.length()); |
(...skipping 421 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
480 return true; | 610 return true; |
481 } | 611 } |
482 | 612 |
483 void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Log( | 613 void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Log( |
484 const param_type& p, | 614 const param_type& p, |
485 std::string* l) { | 615 std::string* l) { |
486 l->append("<SignedCertificateTimestamp>"); | 616 l->append("<SignedCertificateTimestamp>"); |
487 } | 617 } |
488 | 618 |
489 } // namespace IPC | 619 } // namespace IPC |
OLD | NEW |