Certificate Transparency: Change CTVerifyResult to have a single list

net/cert/ct_signed_certificate_timestamp_log_param.cc

 // Copyright 2013 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 "net/cert/ct_signed_certificate_timestamp_log_param.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 19 matching lines @@
   std::string b64_value;
   base::Base64Encode(value, &b64_value);
 
   dict->SetString(key, b64_value);
 }
 
 // Returns a dictionary where each key is a field of the SCT and its value
 // is this field's value in the SCT. This dictionary is meant to be used for
 // outputting a de-serialized SCT to the NetLog.
 std::unique_ptr<base::DictionaryValue> SCTToDictionary(
-    const ct::SignedCertificateTimestamp& sct) {
+    const ct::SignedCertificateTimestamp& sct,
+    ct::SCTVerifyStatus status) {
   std::unique_ptr<base::DictionaryValue> out(new base::DictionaryValue());
 
   out->SetString("origin", OriginToString(sct.origin));
+  out->SetString("verification_status", StatusToString(status));
   out->SetInteger("version", sct.version);
 
   SetBinaryData("log_id", sct.log_id, out.get());
   base::TimeDelta time_since_unix_epoch =
       sct.timestamp - base::Time::UnixEpoch();
   out->SetString("timestamp",
       base::Int64ToString(time_since_unix_epoch.InMilliseconds()));
   SetBinaryData("extensions", sct.extensions, out.get());
 
   out->SetString("hash_algorithm",
                  HashAlgorithmToString(sct.signature.hash_algorithm));
   out->SetString("signature_algorithm",
                  SignatureAlgorithmToString(sct.signature.signature_algorithm));
   SetBinaryData("signature_data", sct.signature.signature_data, out.get());
 
   return out;
 }
 
-// Given a list of SCTs, return a ListValue instance where each item in the
-// list is a dictionary created by SCTToDictionary.
+// Given a list of SCTs and their statuses, return a ListValue instance where
+// each item in the list is a dictionary created by SCTToDictionary.
 std::unique_ptr<base::ListValue> SCTListToPrintableValues(
-    const ct::SCTList& sct_list) {
+    const SignedCertificateTimestampAndStatusList& sct_and_status_list) {
   std::unique_ptr<base::ListValue> output_scts(new base::ListValue());
-  for (const auto& sct : sct_list)
-    output_scts->Append(SCTToDictionary(*(sct.get())));
+  for (const auto& sct_and_status : sct_and_status_list)
+    output_scts->Append(
+        SCTToDictionary(*(sct_and_status.sct.get()), sct_and_status.status));
 
   return output_scts;
 }
 
 }  // namespace
 
 std::unique_ptr<base::Value> NetLogSignedCertificateTimestampCallback(
     const ct::CTVerifyResult* ct_result,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
-  dict->Set("verified_scts",
-            SCTListToPrintableValues(ct_result->verified_scts));
-
-  dict->Set("invalid_scts",
-            SCTListToPrintableValues(ct_result->invalid_scts));
-
-  dict->Set("unknown_logs_scts",
-            SCTListToPrintableValues(ct_result->unknown_logs_scts));
+  dict->Set("scts", SCTListToPrintableValues(ct_result->scts));
 
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogRawSignedCertificateTimestampCallback(
     const std::string* embedded_scts,
     const std::string* sct_list_from_ocsp,
     const std::string* sct_list_from_tls_extension,
     NetLogCaptureMode capture_mode) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   SetBinaryData("embedded_scts", *embedded_scts, dict.get());
   SetBinaryData("scts_from_ocsp_response", *sct_list_from_ocsp, dict.get());
   SetBinaryData("scts_from_tls_extension", *sct_list_from_tls_extension,
                 dict.get());
 
   return std::move(dict);
 }
 
 }  // namespace net