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

net/cert/ct_serialization_unittest.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 <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 61 matching lines @@
   digitally_signed.hash_algorithm = ct::DigitallySigned::HASH_ALGO_SHA256;
   digitally_signed.signature_algorithm = ct::DigitallySigned::SIG_ALGO_ECDSA;
   digitally_signed.signature_data = test_digitally_signed_.substr(4);
 
   std::string encoded;
 
   ASSERT_TRUE(ct::EncodeDigitallySigned(digitally_signed, &encoded));
   EXPECT_EQ(test_digitally_signed_, encoded);
 }
 
-
-TEST_F(CtSerializationTest, EncodesLogEntryForX509Cert) {
-  ct::LogEntry entry;
-  ct::GetX509CertLogEntry(&entry);
+TEST_F(CtSerializationTest, EncodesSignedEntryForX509Cert) {
+  ct::SignedEntryData entry;
+  ct::GetX509CertSignedEntry(&entry);
 
   std::string encoded;
-  ASSERT_TRUE(ct::EncodeLogEntry(entry, &encoded));
+  ASSERT_TRUE(ct::EncodeSignedEntry(entry, &encoded));
   EXPECT_EQ((718U + 5U), encoded.size());
   // First two bytes are log entry type. Next, length:
   // Length is 718 which is 512 + 206, which is 0x2ce
   std::string expected_prefix("\0\0\0\x2\xCE", 5);
   // Note we use std::string comparison rather than ASSERT_STREQ due
   // to null characters in the buffer.
   EXPECT_EQ(expected_prefix, encoded.substr(0, 5));
 }
 
-TEST_F(CtSerializationTest, EncodesLogEntryForPrecert) {
-  ct::LogEntry entry;
-  ct::GetPrecertLogEntry(&entry);
+TEST_F(CtSerializationTest, EncodesSignedEntryForPrecert) {
+  ct::SignedEntryData entry;
+  ct::GetPrecertSignedEntry(&entry);
 
   std::string encoded;
-  ASSERT_TRUE(ct::EncodeLogEntry(entry, &encoded));
+  ASSERT_TRUE(ct::EncodeSignedEntry(entry, &encoded));
   EXPECT_EQ(604u, encoded.size());
   // First two bytes are the log entry type.
   EXPECT_EQ(std::string("\x00\x01", 2), encoded.substr(0, 2));
   // Next comes the 32-byte issuer key hash
   EXPECT_THAT(encoded.substr(2, 32),
               ElementsAreArray(entry.issuer_key_hash.data));
   // Then the length of the TBS cert (604 bytes = 0x237)
   EXPECT_EQ(std::string("\x00\x02\x37", 3), encoded.substr(34, 3));
   // Then the TBS cert itself
   EXPECT_EQ(entry.tbs_certificate, encoded.substr(37));
@@ skipping 82 matching lines @@
       "Version encoded incorrectly";
   EXPECT_EQ(std::string("\x00", 1), encoded.substr(1, 1)) <<
       "Merkle tree leaf type encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x00\x01\x45\x3c\x5f\xb8\x35", 8),
             encoded.substr(2, 8)) <<
       "Timestamp encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x00", 2), encoded.substr(10, 2)) <<
       "Log entry type encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x02\xce", 3), encoded.substr(12, 3)) <<
       "Certificate length encoded incorrectly";
-  EXPECT_EQ(tree_leaf.log_entry.leaf_certificate, encoded.substr(15, 718)) <<
-      "Certificate encoded incorrectly";
+  EXPECT_EQ(tree_leaf.signed_entry.leaf_certificate, encoded.substr(15, 718))
+      << "Certificate encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x06", 2), encoded.substr(733, 2)) <<
       "CT extensions length encoded incorrectly";
   EXPECT_EQ(tree_leaf.extensions, encoded.substr(735, 6)) <<
       "CT extensions encoded incorrectly";
 }
 
 TEST_F(CtSerializationTest, EncodesMerkleTreeLeafForPrecert) {
   ct::MerkleTreeLeaf tree_leaf;
   ct::GetPrecertTreeLeaf(&tree_leaf);
 
   std::string encoded;
   ASSERT_TRUE(ct::EncodeTreeLeaf(tree_leaf, &encoded));
   EXPECT_EQ(622u, encoded.size()) << "Merkle tree leaf encoded incorrectly";
   EXPECT_EQ(std::string("\x00", 1), encoded.substr(0, 1)) <<
       "Version encoded incorrectly";
   EXPECT_EQ(std::string("\x00", 1), encoded.substr(1, 1)) <<
       "Merkle tree leaf type encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x00\x01\x45\x3c\x5f\xb8\x35", 8),
             encoded.substr(2, 8)) <<
       "Timestamp encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x01", 2), encoded.substr(10, 2)) <<
       "Log entry type encoded incorrectly";
   EXPECT_THAT(encoded.substr(12, 32),
-              ElementsAreArray(tree_leaf.log_entry.issuer_key_hash.data)) <<
-      "Issuer key hash encoded incorrectly";
+              ElementsAreArray(tree_leaf.signed_entry.issuer_key_hash.data))
+      << "Issuer key hash encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x02\x37", 3), encoded.substr(44, 3)) <<
       "TBS certificate length encoded incorrectly";
-  EXPECT_EQ(tree_leaf.log_entry.tbs_certificate, encoded.substr(47, 567)) <<
-      "TBS certificate encoded incorrectly";
+  EXPECT_EQ(tree_leaf.signed_entry.tbs_certificate, encoded.substr(47, 567))
+      << "TBS certificate encoded incorrectly";
   EXPECT_EQ(std::string("\x00\x06", 2), encoded.substr(614, 2)) <<
       "CT extensions length encoded incorrectly";
   EXPECT_EQ(tree_leaf.extensions, encoded.substr(616, 6)) <<
       "CT extensions encoded incorrectly";
 }
 
 TEST_F(CtSerializationTest, EncodesValidSignedTreeHead) {
   ct::SignedTreeHead signed_tree_head;
   ASSERT_TRUE(GetSampleSignedTreeHead(&signed_tree_head));
 
   std::string encoded;
   ct::EncodeTreeHeadSignature(signed_tree_head, &encoded);
   // Expected size is 50 bytes:
   // Byte 0 is version, byte 1 is signature type
   // Bytes 2-9 are timestamp
   // Bytes 10-17 are tree size
   // Bytes 18-49 are sha256 root hash
   ASSERT_EQ(50u, encoded.length());
   std::string expected_buffer(
       "\x0\x1\x0\x0\x1\x45\x3c\x5f\xb8\x35\x0\x0\x0\x0\x0\x0\x0\x15", 18);
   expected_buffer.append(ct::GetSampleSTHSHA256RootHash());
   ASSERT_EQ(expected_buffer, encoded);
 }
 
 }  // namespace net