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

net/cert/ct_serialization.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_serialization.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 10 matching lines @@
 namespace ct {
 
 namespace {
 
 // Note: length is always specified in bytes.
 // CT protocol version length
 const size_t kVersionLength = 1;
 
 // Common V1 struct members
 const size_t kTimestampLength = 8;
-const size_t kLogEntryTypeLength = 2;
+const size_t kSignedEntryTypeLength = 2;
 const size_t kAsn1CertificateLengthBytes = 3;
 const size_t kTbsCertificateLengthBytes = 3;
 const size_t kExtensionsLengthBytes = 2;
 
 // Members of a V1 SCT
 const size_t kLogIdLength = crypto::kSHA256Length;
 const size_t kHashAlgorithmLength = 1;
 const size_t kSigAlgorithmLength = 1;
 const size_t kSignatureLengthBytes = 2;
 
@@ skipping 198 matching lines @@
 
   if (input_size > max_input_size)
     return false;
 
   WriteUint(prefix_length, input_size, output);
   WriteEncodedBytes(input, output);
 
   return true;
 }
 
-// Writes a LogEntry of type X.509 cert to |output|.
-// |input| is the LogEntry containing the certificate.
-// Returns true if the leaf_certificate in the LogEntry does not exceed
+// Writes a SignedEntryData of type X.509 cert to |output|.
+// |input| is the SignedEntryData containing the certificate.
+// Returns true if the leaf_certificate in the SignedEntryData does not exceed
 // kMaxAsn1CertificateLength and so can be written to |output|.
-bool EncodeAsn1CertLogEntry(const LogEntry& input, std::string* output) {
+bool EncodeAsn1CertSignedEntry(const SignedEntryData& input,
+                               std::string* output) {
   return WriteVariableBytes(kAsn1CertificateLengthBytes,
                             input.leaf_certificate, output);
 }
 
-// Writes a LogEntry of type PreCertificate to |output|.
-// |input| is the LogEntry containing the TBSCertificate and issuer key hash.
-// Returns true if the TBSCertificate component in the LogEntry does not
-// exceed kMaxTbsCertificateLength and so can be written to |output|.
-bool EncodePrecertLogEntry(const LogEntry& input, std::string* output) {
+// Writes a SignedEntryData of type PreCertificate to |output|.
+// |input| is the SignedEntryData containing the TBSCertificate and issuer key
+// hash. Returns true if the TBSCertificate component in the SignedEntryData
+// does not exceed kMaxTbsCertificateLength and so can be written to |output|.
+bool EncodePrecertSignedEntry(const SignedEntryData& input,
+                              std::string* output) {
   WriteEncodedBytes(
       base::StringPiece(
           reinterpret_cast<const char*>(input.issuer_key_hash.data),
           kIssuerKeyHashLength),
       output);
   return WriteVariableBytes(kTbsCertificateLengthBytes,
                             input.tbs_certificate, output);
 }
 
 }  // namespace
@@ skipping 27 matching lines @@
   if (!ConvertSignatureAlgorithm(sig_algo, &result.signature_algorithm)) {
     DVLOG(1) << "Invalid signature algorithm " << sig_algo;
     return false;
   }
   sig_data.CopyToString(&result.signature_data);
 
   *output = result;
   return true;
 }
 
-bool EncodeLogEntry(const LogEntry& input, std::string* output) {
-  WriteUint(kLogEntryTypeLength, input.type, output);
+bool EncodeSignedEntry(const SignedEntryData& input, std::string* output) {
+  WriteUint(kSignedEntryTypeLength, input.type, output);
   switch (input.type) {
-    case LogEntry::LOG_ENTRY_TYPE_X509:
-      return EncodeAsn1CertLogEntry(input, output);
-    case LogEntry::LOG_ENTRY_TYPE_PRECERT:
-      return EncodePrecertLogEntry(input, output);
+    case SignedEntryData::LOG_ENTRY_TYPE_X509:
+      return EncodeAsn1CertSignedEntry(input, output);
+    case SignedEntryData::LOG_ENTRY_TYPE_PRECERT:
+      return EncodePrecertSignedEntry(input, output);
   }
   return false;
 }
 
 static bool ReadTimeSinceEpoch(base::StringPiece* input, base::Time* output) {
   uint64_t time_since_epoch = 0;
   if (!ReadUint(kTimestampLength, input, &time_since_epoch))
     return false;
 
   base::CheckedNumeric<int64_t> time_since_epoch_signed = time_since_epoch;
@@ skipping 14 matching lines @@
 static void WriteTimeSinceEpoch(const base::Time& timestamp,
                                 std::string* output) {
   base::TimeDelta time_since_epoch = timestamp - base::Time::UnixEpoch();
   WriteUint(kTimestampLength, time_since_epoch.InMilliseconds(), output);
 }
 
 bool EncodeTreeLeaf(const MerkleTreeLeaf& leaf, std::string* output) {
   WriteUint(kVersionLength, 0, output);         // version: 1
   WriteUint(kMerkleLeafTypeLength, 0, output);  // type: timestamped entry
   WriteTimeSinceEpoch(leaf.timestamp, output);
-  if (!EncodeLogEntry(leaf.log_entry, output))
+  if (!EncodeSignedEntry(leaf.signed_entry, output))
     return false;
   if (!WriteVariableBytes(kExtensionsLengthBytes, leaf.extensions, output))
     return false;
 
   return true;
 }
 
 bool EncodeV1SCTSignedData(const base::Time& timestamp,
                            const std::string& serialized_log_entry,
                            const std::string& extensions,
@@ skipping 66 matching lines @@
 bool EncodeSCTListForTesting(const base::StringPiece& sct,
                              std::string* output) {
   std::string encoded_sct;
   return WriteVariableBytes(kSerializedSCTLengthBytes, sct, &encoded_sct) &&
          WriteVariableBytes(kSCTListLengthBytes, encoded_sct, output);
 }
 
 }  // namespace ct
 
 }  // namespace net