Rename net::ct::LogEntry to SignedEntryData and clarify the comment.

net/cert/ct_objects_extractor.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_objects_extractor.h"
 
 #include <string.h>
 
 #include "base/logging.h"
 #include "base/sha1.h"
@@ skipping 155 matching lines @@
   if (!x509)
     return false;
   X509_EXTENSIONS* x509_exts = x509->cert_info->extensions;
   if (!x509_exts)
     return false;
   return GetSCTListFromX509_EXTENSIONS(x509->cert_info->extensions,
                                        kEmbeddedSCTOid, sizeof(kEmbeddedSCTOid),
                                        sct_list);
 }
 
-bool GetPrecertLogEntry(X509Certificate::OSCertHandle leaf,
-                        X509Certificate::OSCertHandle issuer,
-                        LogEntry* result) {
+bool GetPrecertSignedEntry(X509Certificate::OSCertHandle leaf,
+                           X509Certificate::OSCertHandle issuer,
+                           SignedEntryData* result) {
   result->Reset();
 
   bssl::UniquePtr<X509> leaf_x509(OSCertHandleToOpenSSL(leaf));
   if (!leaf_x509)
     return false;
 
   // XXX(rsleevi): This check may be overkill, since we should be able to
   // generate precerts for certs without the extension. For now, just a sanity
   // check to match the reference implementation.
   if (!leaf_x509->cert_info->extensions ||
@@ skipping 32 matching lines @@
     return false;
 
   // Extract the issuer's public key.
   std::string issuer_der;
   if (!X509Certificate::GetDEREncoded(issuer, &issuer_der))
     return false;
   base::StringPiece issuer_key;
   if (!asn1::ExtractSPKIFromDERCert(issuer_der, &issuer_key))
     return false;
 
-  // Fill in the LogEntry.
-  result->type = ct::LogEntry::LOG_ENTRY_TYPE_PRECERT;
+  // Fill in the SignedEntryData.
+  result->type = ct::SignedEntryData::LOG_ENTRY_TYPE_PRECERT;
   result->tbs_certificate.swap(to_be_signed);
   crypto::SHA256HashString(issuer_key, result->issuer_key_hash.data,
                            sizeof(result->issuer_key_hash.data));
 
   return true;
 }
 
-bool GetX509LogEntry(X509Certificate::OSCertHandle leaf, LogEntry* result) {
+bool GetX509SignedEntry(X509Certificate::OSCertHandle leaf,
+                        SignedEntryData* result) {
   DCHECK(leaf);
 
   std::string encoded;
   if (!X509Certificate::GetDEREncoded(leaf, &encoded))
     return false;
 
   result->Reset();
-  result->type = ct::LogEntry::LOG_ENTRY_TYPE_X509;
+  result->type = ct::SignedEntryData::LOG_ENTRY_TYPE_X509;
   result->leaf_certificate.swap(encoded);
   return true;
 }
 
 bool ExtractSCTListFromOCSPResponse(X509Certificate::OSCertHandle issuer,
                                     const std::string& cert_serial_number,
                                     base::StringPiece ocsp_response,
                                     std::string* sct_list) {
   // The input is an OCSPResponse. See RFC2560, section 4.2.1. The SCT list is
   // in the extensions field of the SingleResponse which matches the input
@@ skipping 83 matching lines @@
   if (!x509_exts || ptr != CBS_data(&extensions) + CBS_len(&extensions))
     return false;
 
   return GetSCTListFromX509_EXTENSIONS(x509_exts.get(), kOCSPExtensionOid,
                                        sizeof(kOCSPExtensionOid), sct_list);
 }
 
 }  // namespace ct
 
 }  // namespace net