Clang format slam.

net/cert/x509_certificate_ios.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_certificate.h"
 
 #include <CommonCrypto/CommonDigest.h>
 #include <Security/Security.h>
 
 #include <cert.h>
@@ skipping 58 matching lines @@
   fingerprint_ = CalculateFingerprint(cert_handle_);
   ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
 }
 
 bool X509Certificate::IsIssuedByEncoded(
     const std::vector<std::string>& valid_issuers) {
   x509_util_ios::NSSCertChain nss_chain(this);
   // Convert to scoped CERTName* list.
   std::vector<CERTName*> issuers;
   crypto::ScopedPLArenaPool arena(PORT_NewArena(DER_DEFAULT_CHUNKSIZE));
-  if (!x509_util::GetIssuersFromEncodedList(valid_issuers,
-                                            arena.get(),
-                                            &issuers)) {
+  if (!x509_util::GetIssuersFromEncodedList(
+          valid_issuers, arena.get(), &issuers)) {
     return false;
   }
-  return x509_util::IsCertificateIssuedBy(
-      nss_chain.cert_chain(), issuers);
+  return x509_util::IsCertificateIssuedBy(nss_chain.cert_chain(), issuers);
 }
 
 void X509Certificate::GetSubjectAltName(
     std::vector<std::string>* dns_names,
     std::vector<std::string>* ip_addrs) const {
   x509_util_ios::NSSCertificate nss_cert(cert_handle_);
   CERTCertificate* cert_handle = nss_cert.cert_handle();
   if (!cert_handle) {
     if (dns_names)
       dns_names->clear();
@@ skipping 20 matching lines @@
                                    X509Certificate::OSCertHandle b) {
   DCHECK(a && b);
   if (a == b)
     return true;
   if (CFEqual(a, b))
     return true;
   ScopedCFTypeRef<CFDataRef> a_data(SecCertificateCopyData(a));
   ScopedCFTypeRef<CFDataRef> b_data(SecCertificateCopyData(b));
   return a_data && b_data &&
          CFDataGetLength(a_data) == CFDataGetLength(b_data) &&
-         memcmp(CFDataGetBytePtr(a_data), CFDataGetBytePtr(b_data),
+         memcmp(CFDataGetBytePtr(a_data),
+                CFDataGetBytePtr(b_data),
                 CFDataGetLength(a_data)) == 0;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
-    const char* data, int length) {
-  ScopedCFTypeRef<CFDataRef> cert_data(CFDataCreateWithBytesNoCopy(
-      kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(data), length,
-      kCFAllocatorNull));
+    const char* data,
+    int length) {
+  ScopedCFTypeRef<CFDataRef> cert_data(
+      CFDataCreateWithBytesNoCopy(kCFAllocatorDefault,
+                                  reinterpret_cast<const UInt8*>(data),
+                                  length,
+                                  kCFAllocatorNull));
   if (!cert_data)
     return NULL;
   OSCertHandle cert_handle = SecCertificateCreateWithData(NULL, cert_data);
   if (!cert_handle)
     return NULL;
   if (!IsValidOSCertHandle(cert_handle)) {
     CFRelease(cert_handle);
     return NULL;
   }
   return cert_handle;
@@ skipping 14 matching lines @@
     return NULL;
   return reinterpret_cast<OSCertHandle>(const_cast<void*>(CFRetain(handle)));
 }
 
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   CFRelease(cert_handle);
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(
-    OSCertHandle cert) {
+SHA1HashValue X509Certificate::CalculateFingerprint(OSCertHandle cert) {
   SHA1HashValue sha1;
   memset(sha1.data, 0, sizeof(sha1.data));
 
   ScopedCFTypeRef<CFDataRef> cert_data(SecCertificateCopyData(cert));
   if (!cert_data)
     return sha1;
   DCHECK(CFDataGetBytePtr(cert_data));
   DCHECK_NE(0, CFDataGetLength(cert_data));
   CC_SHA1(CFDataGetBytePtr(cert_data), CFDataGetLength(cert_data), sha1.data);
 
   return sha1;
 }
 
 // static
 SHA1HashValue X509Certificate::CalculateCAFingerprint(
     const OSCertHandles& intermediates) {
   SHA1HashValue sha1;
   memset(sha1.data, 0, sizeof(sha1.data));
 
   // The CC_SHA(3cc) man page says all CC_SHA1_xxx routines return 1, so
   // we don't check their return values.
   CC_SHA1_CTX sha1_ctx;
   CC_SHA1_Init(&sha1_ctx);
   for (size_t i = 0; i < intermediates.size(); ++i) {
-    ScopedCFTypeRef<CFDataRef>
-        cert_data(SecCertificateCopyData(intermediates[i]));
+    ScopedCFTypeRef<CFDataRef> cert_data(
+        SecCertificateCopyData(intermediates[i]));
     if (!cert_data)
       return sha1;
-    CC_SHA1_Update(&sha1_ctx,
-                   CFDataGetBytePtr(cert_data),
-                   CFDataGetLength(cert_data));
+    CC_SHA1_Update(
+        &sha1_ctx, CFDataGetBytePtr(cert_data), CFDataGetLength(cert_data));
   }
   CC_SHA1_Final(sha1.data, &sha1_ctx);
   return sha1;
 }
 
 // static
-X509Certificate::OSCertHandle
-X509Certificate::ReadOSCertHandleFromPickle(PickleIterator* pickle_iter) {
+X509Certificate::OSCertHandle X509Certificate::ReadOSCertHandleFromPickle(
+    PickleIterator* pickle_iter) {
   return x509_util::ReadOSCertHandleFromPickle(pickle_iter);
 }
 
 // static
 bool X509Certificate::WriteOSCertHandleToPickle(OSCertHandle cert_handle,
                                                 Pickle* pickle) {
   ScopedCFTypeRef<CFDataRef> cert_data(SecCertificateCopyData(cert_handle));
   if (!cert_data)
     return false;
 
   return pickle->WriteData(
       reinterpret_cast<const char*>(CFDataGetBytePtr(cert_data)),
       CFDataGetLength(cert_data));
 }
 
 // static
 void X509Certificate::GetPublicKeyInfo(OSCertHandle cert_handle,
                                        size_t* size_bits,
                                        PublicKeyType* type) {
   x509_util_ios::NSSCertificate nss_cert(cert_handle);
   x509_util::GetPublicKeyInfo(nss_cert.cert_handle(), size_bits, type);
 }
 
 }  // namespace net