Clang format slam.

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 "base/basictypes.h"
 #include "base/logging.h"
 
 namespace net {
@@ skipping 135 matching lines @@
       return false;
   }
   *out = static_cast<DigitallySigned::HashAlgorithm>(in);
   return true;
 }
 
 // Checks and converts a signing algorithm.
 // |in| is the numeric representation of the algorithm.
 // If the signing algorithm value is in a set of known values, fills in |out|
 // and returns true. Otherwise, returns false.
-bool ConvertSignatureAlgorithm(
-    unsigned in,
-    DigitallySigned::SignatureAlgorithm* out) {
+bool ConvertSignatureAlgorithm(unsigned in,
+                               DigitallySigned::SignatureAlgorithm* out) {
   switch (in) {
     case DigitallySigned::SIG_ALGO_ANONYMOUS:
     case DigitallySigned::SIG_ALGO_RSA:
     case DigitallySigned::SIG_ALGO_DSA:
     case DigitallySigned::SIG_ALGO_ECDSA:
       break;
     default:
       return false;
   }
   *out = static_cast<DigitallySigned::SignatureAlgorithm>(in);
   return true;
 }
 
 // Writes a TLS-encoded variable length unsigned integer to |output|.
 // |length| indicates the size (in bytes) of the integer.
 // |value| the value itself to be written.
 template <typename T>
 void WriteUint(size_t length, T value, std::string* output) {
   DCHECK_LE(length, sizeof(T));
   DCHECK(length == sizeof(T) || value >> (length * 8) == 0);
 
   for (; length > 0; --length) {
-    output->push_back((value >> ((length - 1)* 8)) & 0xFF);
+    output->push_back((value >> ((length - 1) * 8)) & 0xFF);
   }
 }
 
 // Writes an array to |output| from |input|.
 // Should be used in one of two cases:
 // * The length of |input| has already been encoded into the |output| stream.
 // * The length of |input| is fixed and the reader is expected to specify that
 // length when reading.
 // If the length of |input| is dynamic and data is expected to follow it,
 // WriteVariableBytes must be used.
@@ skipping 19 matching lines @@
   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
 // kMaxAsn1CertificateLength and so can be written to |output|.
 bool EncodeAsn1CertLogEntry(const LogEntry& input, std::string* output) {
-  return WriteVariableBytes(kAsn1CertificateLengthBytes,
-                            input.leaf_certificate, 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) {
-  WriteEncodedBytes(
-      base::StringPiece(
-          reinterpret_cast<const char*>(input.issuer_key_hash.data),
-          kLogIdLength),
-      output);
-  return WriteVariableBytes(kTbsCertificateLengthBytes,
-                            input.tbs_certificate, output);
+  WriteEncodedBytes(base::StringPiece(reinterpret_cast<const char*>(
+                                          input.issuer_key_hash.data),
+                                      kLogIdLength),
+                    output);
+  return WriteVariableBytes(
+      kTbsCertificateLengthBytes, input.tbs_certificate, output);
 }
 
 }  // namespace
 
-bool EncodeDigitallySigned(const DigitallySigned& input,
-                           std::string* output) {
+bool EncodeDigitallySigned(const DigitallySigned& input, std::string* output) {
   WriteUint(kHashAlgorithmLength, input.hash_algorithm, output);
-  WriteUint(kSigAlgorithmLength, input.signature_algorithm,
-            output);
-  return WriteVariableBytes(kSignatureLengthBytes, input.signature_data,
-                            output);
+  WriteUint(kSigAlgorithmLength, input.signature_algorithm, output);
+  return WriteVariableBytes(
+      kSignatureLengthBytes, input.signature_data, output);
 }
 
-bool DecodeDigitallySigned(base::StringPiece* input,
-                           DigitallySigned* output) {
+bool DecodeDigitallySigned(base::StringPiece* input, DigitallySigned* output) {
   unsigned hash_algo;
   unsigned sig_algo;
   base::StringPiece sig_data;
 
   if (!ReadUint(kHashAlgorithmLength, input, &hash_algo) ||
       !ReadUint(kSigAlgorithmLength, input, &sig_algo) ||
       !ReadVariableBytes(kSignatureLengthBytes, input, &sig_data)) {
     return false;
   }
 
@@ skipping 20 matching lines @@
     case LogEntry::LOG_ENTRY_TYPE_PRECERT:
       return EncodePrecertLogEntry(input, output);
   }
   return false;
 }
 
 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,
-            output);
-  WriteUint(kSignatureTypeLength, SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP,
-            output);
+  WriteUint(kVersionLength, SignedCertificateTimestamp::SCT_VERSION_1, output);
+  WriteUint(kSignatureTypeLength, SIGNATURE_TYPE_CERTIFICATE_TIMESTAMP, output);
   base::TimeDelta time_since_epoch = timestamp - base::Time::UnixEpoch();
-  WriteUint(kTimestampLength, time_since_epoch.InMilliseconds(),
-            output);
+  WriteUint(kTimestampLength, time_since_epoch.InMilliseconds(), 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);
 }
 
 bool DecodeSCTList(base::StringPiece* input,
                    std::vector<base::StringPiece>* output) {
   std::vector<base::StringPiece> result;
-  if (!ReadList(kSCTListLengthBytes, kSerializedSCTLengthBytes,
-                input, &result)) {
+  if (!ReadList(
+          kSCTListLengthBytes, kSerializedSCTLengthBytes, input, &result)) {
     return false;
   }
 
   if (!input->empty() || result.empty())
     return false;
   output->swap(result);
   return true;
 }
 
 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) {
     DVLOG(1) << "Unsupported/invalid version " << version;
     return false;
   }
 
   result->version = SignedCertificateTimestamp::SCT_VERSION_1;
   uint64 timestamp;
   base::StringPiece log_id;
   base::StringPiece extensions;
   if (!ReadFixedBytes(kLogIdLength, input, &log_id) ||
       !ReadUint(kTimestampLength, input, &timestamp) ||
-      !ReadVariableBytes(kExtensionsLengthBytes, input,
-                         &extensions) ||
+      !ReadVariableBytes(kExtensionsLengthBytes, input, &extensions) ||
       !DecodeDigitallySigned(input, &result->signature)) {
     return false;
   }
 
   if (timestamp > static_cast<uint64>(kint64max)) {
     DVLOG(1) << "Timestamp value too big to cast to int64: " << timestamp;
     return false;
   }
 
   log_id.CopyToString(&result->log_id);
   extensions.CopyToString(&result->extensions);
   result->timestamp =
       base::Time::UnixEpoch() +
       base::TimeDelta::FromMilliseconds(static_cast<int64>(timestamp));
 
   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);
+         WriteVariableBytes(kSCTListLengthBytes, encoded_sct, output);
 }
 
 }  // namespace ct
 
 }  // namespace net