Clang format slam.

net/cert/x509_util_openssl.cc

 // Copyright (c) 2012 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/x509_util_openssl.h"
 
 #include <algorithm>
 #include <openssl/asn1.h>
 
 #include "base/lazy_instance.h"
@@ skipping 70 matching lines @@
     LOG(ERROR) << "Common name too long";
     return NULL;
   }
   unsigned char* common_name_str =
       reinterpret_cast<unsigned char*>(const_cast<char*>(common_name.data())) +
       kCommonNamePrefixLen;
   int common_name_len =
       static_cast<int>(common_name.size() - kCommonNamePrefixLen);
 
   crypto::ScopedOpenSSL<X509_NAME, X509_NAME_free> name(X509_NAME_new());
-  if (!name.get() || !X509_NAME_add_entry_by_NID(name.get(),
-                                                 NID_commonName,
-                                                 MBSTRING_ASC,
-                                                 common_name_str,
-                                                 common_name_len,
-                                                 -1,
-                                                 0)) {
+  if (!name.get() ||
+      !X509_NAME_add_entry_by_NID(name.get(),
+                                  NID_commonName,
+                                  MBSTRING_ASC,
+                                  common_name_str,
+                                  common_name_len,
+                                  -1,
+                                  0)) {
     LOG(ERROR) << "Can't parse common name: " << common_name.c_str();
     return NULL;
   }
 
   // Now create certificate and populate it.
   crypto::ScopedOpenSSL<X509, X509_free> cert(X509_new());
   if (!cert.get() || !X509_set_version(cert.get(), 2L) /* i.e. version 3 */ ||
       !X509_set_pubkey(cert.get(), key) ||
       !X509_set_serialNumber(cert.get(), asn1_serial.get()) ||
       !X509_set_notBefore(cert.get(), asn1_not_before_time.get()) ||
@@ skipping 84 matching lines @@
   //
   //     from datetime import date as D
   //     print (D(1970,1,1)-D(1,1,1))        # -> 719162 days
   //     print (D(9999,12,31)-D(1970,1,1))   # -> 2932896 days
   //
   // Note: This ignores leap seconds, but should be enough in practice.
   //
   const int64 kDaysFromYear0001ToUnixEpoch = 719162;
   const int64 kDaysFromUnixEpochToYear10000 = 2932896 + 1;
   const base::Time kEpoch = base::Time::UnixEpoch();
-  const base::Time kYear0001 = kEpoch -
-      base::TimeDelta::FromDays(kDaysFromYear0001ToUnixEpoch);
-  const base::Time kYear10000 = kEpoch +
-      base::TimeDelta::FromDays(kDaysFromUnixEpochToYear10000);
+  const base::Time kYear0001 =
+      kEpoch - base::TimeDelta::FromDays(kDaysFromYear0001ToUnixEpoch);
+  const base::Time kYear10000 =
+      kEpoch + base::TimeDelta::FromDays(kDaysFromUnixEpochToYear10000);
 
   if (not_valid_before < kYear0001 || not_valid_before >= kYear10000 ||
       not_valid_after < kYear0001 || not_valid_after >= kYear10000)
     return false;
 
   return true;
 }
 
-bool CreateDomainBoundCertEC(
-    crypto::ECPrivateKey* key,
-    DigestAlgorithm alg,
-    const std::string& domain,
-    uint32 serial_number,
-    base::Time not_valid_before,
-    base::Time not_valid_after,
-    std::string* der_cert) {
+bool CreateDomainBoundCertEC(crypto::ECPrivateKey* key,
+                             DigestAlgorithm alg,
+                             const std::string& domain,
+                             uint32 serial_number,
+                             base::Time not_valid_before,
+                             base::Time not_valid_after,
+                             std::string* der_cert) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
   // Create certificate.
   crypto::ScopedOpenSSL<X509, X509_free> cert(
       CreateCertificate(key->key(),
                         alg,
                         "CN=anonymous.invalid",
                         serial_number,
                         not_valid_before,
                         not_valid_after));
   if (!cert.get())
@@ skipping 91 matching lines @@
 
 bool ParsePrincipalValueByNID(X509_NAME* name, int nid, std::string* value) {
   int index = X509_NAME_get_index_by_NID(name, nid, -1);
   if (index < 0)
     return false;
 
   return ParsePrincipalValueByIndex(name, index, value);
 }
 
 bool ParseDate(ASN1_TIME* x509_time, base::Time* time) {
-  if (!x509_time ||
-      (x509_time->type != V_ASN1_UTCTIME &&
-       x509_time->type != V_ASN1_GENERALIZEDTIME))
+  if (!x509_time || (x509_time->type != V_ASN1_UTCTIME &&
+                     x509_time->type != V_ASN1_GENERALIZEDTIME))
     return false;
 
   base::StringPiece str_date(reinterpret_cast<const char*>(x509_time->data),
                              x509_time->length);
 
-  CertDateFormat format = x509_time->type == V_ASN1_UTCTIME ?
-      CERT_DATE_FORMAT_UTC_TIME : CERT_DATE_FORMAT_GENERALIZED_TIME;
+  CertDateFormat format = x509_time->type == V_ASN1_UTCTIME
+                              ? CERT_DATE_FORMAT_UTC_TIME
+                              : CERT_DATE_FORMAT_GENERALIZED_TIME;
   return ParseCertificateDate(str_date, format, time);
 }
 
 }  // namespace x509_util
 
 }  // namespace net