Remove the EV Certs Whitelist

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 83 matching lines @@
   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) {
   WriteParam(m, p.is_valid());
   if (!p.is_valid())
     return;
   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) {
   bool is_valid = false;
   if (!ReadParam(m, iter, &is_valid))
@@ skipping 10 matching lines @@
          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->pinning_failure_log) &&
          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,
@@ skipping 450 matching lines @@
   return true;
 }
 
 void ParamTraits<scoped_refptr<net::ct::SignedCertificateTimestamp>>::Log(
     const param_type& p,
     std::string* l) {
   l->append("<SignedCertificateTimestamp>");
 }
 
 }  // namespace IPC