Consistent SignedCertificateTimestamp::Version and SignedTreeHead::Version

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 321 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 EncodeV1SCTSignedData(const base::Time& timestamp,
                            const std::string& serialized_log_entry,
                            const std::string& extensions,
                            std::string* output) {
-  WriteUint(kVersionLength, SignedCertificateTimestamp::SCT_VERSION_1,
+  WriteUint(kVersionLength, SignedCertificateTimestamp::V1,
             output);
   WriteUint(kSignatureTypeLength, SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP,
             output);
   WriteTimeSinceEpoch(timestamp, output);
   // NOTE: serialized_log_entry must already be serialized and contain the
   // length as the prefix.
   WriteEncodedBytes(serialized_log_entry, output);
   return WriteVariableBytes(kExtensionsLengthBytes, extensions, output);
 }
 
@@ skipping 23 matching lines @@
 }
 
 bool DecodeSignedCertificateTimestamp(
     base::StringPiece* input,
     scoped_refptr<SignedCertificateTimestamp>* output) {
   scoped_refptr<SignedCertificateTimestamp> result(
       new SignedCertificateTimestamp());
   unsigned version;
   if (!ReadUint(kVersionLength, input, &version))
     return false;
-  if (version != SignedCertificateTimestamp::SCT_VERSION_1) {
+  if (version != SignedCertificateTimestamp::V1) {
     DVLOG(1) << "Unsupported/invalid version " << version;
     return false;
   }
 
-  result->version = SignedCertificateTimestamp::SCT_VERSION_1;
+  result->version = SignedCertificateTimestamp::V1;
   base::StringPiece log_id;
   base::StringPiece extensions;
   if (!ReadFixedBytes(kLogIdLength, input, &log_id) ||
       !ReadTimeSinceEpoch(input, &result->timestamp) ||
       !ReadVariableBytes(kExtensionsLengthBytes, input, &extensions) ||
       !DecodeDigitallySigned(input, &result->signature)) {
     return false;
   }
 
   log_id.CopyToString(&result->log_id);
   extensions.CopyToString(&result->extensions);
   output->swap(result);
   return true;
 }
 
 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