Clang format slam.

net/cert/x509_certificate_openssl.cc

Index: net/cert/x509_certificate_openssl.cc
diff --git a/net/cert/x509_certificate_openssl.cc b/net/cert/x509_certificate_openssl.cc
index 71d558ddc84b296d4490639c988488ae8af4ab45..088901a7700bfefb601651ec116df514373f6da3 100644
--- a/net/cert/x509_certificate_openssl.cc
+++ b/net/cert/x509_certificate_openssl.cc
@@ -33,7 +33,8 @@ namespace net {
 namespace {
 
 void CreateOSCertHandlesFromPKCS7Bytes(
-    const char* data, int length,
+    const char* data,
+    int length,
     X509Certificate::OSCertHandles* handles) {
   crypto::EnsureOpenSSLInit();
   const unsigned char* der_data = reinterpret_cast<const unsigned char*>(data);
@@ -77,23 +78,24 @@ void ParsePrincipal(X509Certificate::OSCertHandle cert,
   if (!x509_name)
     return;
 
-  ParsePrincipalValues(x509_name, NID_streetAddress,
-                       &principal->street_addresses);
-  ParsePrincipalValues(x509_name, NID_organizationName,
-                       &principal->organization_names);
-  ParsePrincipalValues(x509_name, NID_organizationalUnitName,
+  ParsePrincipalValues(
+      x509_name, NID_streetAddress, &principal->street_addresses);
+  ParsePrincipalValues(
+      x509_name, NID_organizationName, &principal->organization_names);
+  ParsePrincipalValues(x509_name,
+                       NID_organizationalUnitName,
                        &principal->organization_unit_names);
-  ParsePrincipalValues(x509_name, NID_domainComponent,
-                       &principal->domain_components);
-
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_commonName,
-                                      &principal->common_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_localityName,
-                                      &principal->locality_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_stateOrProvinceName,
-                                      &principal->state_or_province_name);
-  x509_util::ParsePrincipalValueByNID(x509_name, NID_countryName,
-                                      &principal->country_name);
+  ParsePrincipalValues(
+      x509_name, NID_domainComponent, &principal->domain_components);
+
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_commonName, &principal->common_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_localityName, &principal->locality_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_stateOrProvinceName, &principal->state_or_province_name);
+  x509_util::ParsePrincipalValueByNID(
+      x509_name, NID_countryName, &principal->country_name);
 }
 
 void ParseSubjectAltName(X509Certificate::OSCertHandle cert,
@@ -143,13 +145,17 @@ struct DERCache {
   int data_length;
 };
 
-void DERCache_free(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx,
-                   long argl, void* argp) {
+void DERCache_free(void* parent,
+                   void* ptr,
+                   CRYPTO_EX_DATA* ad,
+                   int idx,
+                   long argl,
+                   void* argp) {
   DERCache* der_cache = static_cast<DERCache*>(ptr);
   if (!der_cache)
-      return;
+    return;
   if (der_cache->data)
-      OPENSSL_free(der_cache->data);
+    OPENSSL_free(der_cache->data);
   OPENSSL_free(der_cache);
 }
 
@@ -192,8 +198,8 @@ DERCache* SetDERCache(X509Certificate::OSCertHandle cert,
                       int x509_der_cache_index,
                       unsigned char* data,
                       int data_length) {
-  DERCache* internal_cache = static_cast<DERCache*>(
-      OPENSSL_malloc(sizeof(*internal_cache)));
+  DERCache* internal_cache =
+      static_cast<DERCache*>(OPENSSL_malloc(sizeof(*internal_cache)));
   if (!internal_cache) {
     // We took ownership of |data|, so we must free if we can't add it to
     // |cert|.
@@ -218,8 +224,8 @@ bool GetDERAndCacheIfNeeded(X509Certificate::OSCertHandle cert,
   // Re-encoding the DER data via i2d_X509 is an expensive operation, but it's
   // necessary for comparing two certificates. We re-encode at most once per
   // certificate and cache the data within the X509 cert using X509_set_ex_data.
-  DERCache* internal_cache = static_cast<DERCache*>(
-      X509_get_ex_data(cert, x509_der_cache_index));
+  DERCache* internal_cache =
+      static_cast<DERCache*>(X509_get_ex_data(cert, x509_der_cache_index));
   if (!internal_cache) {
     unsigned char* data = NULL;
     int data_length = i2d_X509(cert, &data);
@@ -234,7 +240,7 @@ bool GetDERAndCacheIfNeeded(X509Certificate::OSCertHandle cert,
 }
 
 // Used to free a list of X509_NAMEs and the objects it points to.
-void sk_X509_NAME_free_all(STACK_OF(X509_NAME)* sk) {
+void sk_X509_NAME_free_all(STACK_OF(X509_NAME) * sk) {
   sk_X509_NAME_pop_free(sk, X509_NAME_free);
 }
 
@@ -323,12 +329,12 @@ SHA1HashValue X509Certificate::CalculateCAFingerprint(
 
 // static
 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
-    const char* data, int length) {
+    const char* data,
+    int length) {
   if (length < 0)
     return NULL;
   crypto::EnsureOpenSSLInit();
-  const unsigned char* d2i_data =
-      reinterpret_cast<const unsigned char*>(data);
+  const unsigned char* d2i_data = reinterpret_cast<const unsigned char*>(data);
   // Don't cache this data via SetDERCache as this wire format may be not be
   // identical from the i2d_X509 roundtrip.
   X509* cert = d2i_X509(NULL, &d2i_data, length);
@@ -337,7 +343,9 @@ X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
 
 // static
 X509Certificate::OSCertHandles X509Certificate::CreateOSCertHandlesFromBytes(
-    const char* data, int length, Format format) {
+    const char* data,
+    int length,
+    Format format) {
   OSCertHandles results;
   if (length < 0)
     return results;
@@ -402,14 +410,15 @@ bool X509Certificate::IsSameOSCert(X509Certificate::OSCertHandle a,
   DERCache der_cache_a, der_cache_b;
 
   return GetDERAndCacheIfNeeded(a, &der_cache_a) &&
-      GetDERAndCacheIfNeeded(b, &der_cache_b) &&
-      der_cache_a.data_length == der_cache_b.data_length &&
-      memcmp(der_cache_a.data, der_cache_b.data, der_cache_a.data_length) == 0;
+         GetDERAndCacheIfNeeded(b, &der_cache_b) &&
+         der_cache_a.data_length == der_cache_b.data_length &&
+         memcmp(der_cache_a.data, der_cache_b.data, der_cache_a.data_length) ==
+             0;
 }
 
 // static
-X509Certificate::OSCertHandle
-X509Certificate::ReadOSCertHandleFromPickle(PickleIterator* pickle_iter) {
+X509Certificate::OSCertHandle X509Certificate::ReadOSCertHandleFromPickle(
+    PickleIterator* pickle_iter) {
   const char* data;
   int length;
   if (!pickle_iter->ReadData(&data, &length))
@@ -425,9 +434,8 @@ bool X509Certificate::WriteOSCertHandleToPickle(OSCertHandle cert_handle,
   if (!GetDERAndCacheIfNeeded(cert_handle, &der_cache))
     return false;
 
-  return pickle->WriteData(
-      reinterpret_cast<const char*>(der_cache.data),
-      der_cache.data_length);
+  return pickle->WriteData(reinterpret_cast<const char*>(der_cache.data),
+                           der_cache.data_length);
 }
 
 // static
@@ -478,9 +486,9 @@ bool X509Certificate::IsIssuedByEncoded(
     return false;
 
   for (std::vector<std::string>::const_iterator it = valid_issuers.begin();
-      it != valid_issuers.end(); ++it) {
-    const unsigned char* p =
-        reinterpret_cast<const unsigned char*>(it->data());
+       it != valid_issuers.end();
+       ++it) {
+    const unsigned char* p = reinterpret_cast<const unsigned char*>(it->data());
     long len = static_cast<long>(it->length());
     X509_NAME* ca_name = d2i_X509_NAME(NULL, &p, len);
     if (ca_name == NULL)
@@ -497,7 +505,8 @@ bool X509Certificate::IsIssuedByEncoded(
 
   cert_names.push_back(issuer);
   for (OSCertHandles::iterator it = intermediate_ca_certs_.begin();
-      it != intermediate_ca_certs_.end(); ++it) {
+       it != intermediate_ca_certs_.end();
+       ++it) {
     issuer = X509_get_issuer_name(*it);
     if (issuer == NULL)
       return false;