Clang format slam.

net/cert/x509_cert_types_mac.cc

Index: net/cert/x509_cert_types_mac.cc
diff --git a/net/cert/x509_cert_types_mac.cc b/net/cert/x509_cert_types_mac.cc
index 244fe99d649efe1146904ee31e5846f14fd9339d..339f56536c898c5fe1df43e7216b54e75fe85143 100644
--- a/net/cert/x509_cert_types_mac.cc
+++ b/net/cert/x509_cert_types_mac.cc
@@ -29,24 +29,17 @@ namespace {
 // as long as the symbols are properly exposed. The fact that Apple's
 // implementation stores it in BER is an internal implementation detail
 // observed by studying libsecurity_cssm.
-const uint8 kDomainComponentData[] = {
-  0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x19
-};
+const uint8 kDomainComponentData[] = {0x09, 0x92, 0x26, 0x89, 0x93,
+                                      0xF2, 0x2C, 0x64, 0x01, 0x19};
 
-const CSSM_OID kDomainComponentOID = {
-    arraysize(kDomainComponentData),
-    const_cast<uint8*>(kDomainComponentData)
-};
+const CSSM_OID kDomainComponentOID = {arraysize(kDomainComponentData),
+                                      const_cast<uint8*>(kDomainComponentData)};
 
 const CSSM_OID* kOIDs[] = {
-    &CSSMOID_CommonName,
-    &CSSMOID_LocalityName,
-    &CSSMOID_StateProvinceName,
-    &CSSMOID_CountryName,
-    &CSSMOID_StreetAddress,
-    &CSSMOID_OrganizationName,
-    &CSSMOID_OrganizationalUnitName,
-    &kDomainComponentOID,
+    &CSSMOID_CommonName,             &CSSMOID_LocalityName,
+    &CSSMOID_StateProvinceName,      &CSSMOID_CountryName,
+    &CSSMOID_StreetAddress,          &CSSMOID_OrganizationName,
+    &CSSMOID_OrganizationalUnitName, &kDomainComponentOID,
 };
 
 // The following structs and templates work with Apple's very arcane and under-
@@ -58,58 +51,57 @@ const CSSM_OID* kOIDs[] = {
 // BER DistinguishedName structure.
 
 const SecAsn1Template kStringValueTemplate[] = {
-  { SEC_ASN1_CHOICE, offsetof(CSSM_X509_TYPE_VALUE_PAIR, valueType), },
-  { SEC_ASN1_PRINTABLE_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_PRINTABLE_STRING },
-  { SEC_ASN1_IA5_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_IA5_STRING },
-  { SEC_ASN1_T61_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_T61_STRING },
-  { SEC_ASN1_UTF8_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_PKIX_UTF8_STRING },
-  { SEC_ASN1_BMP_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_PKIX_BMP_STRING },
-  { SEC_ASN1_UNIVERSAL_STRING,
-    offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
-    BER_TAG_PKIX_UNIVERSAL_STRING },
-  { 0, }
-};
+    {
+     SEC_ASN1_CHOICE, offsetof(CSSM_X509_TYPE_VALUE_PAIR, valueType),
+    },
+    {SEC_ASN1_PRINTABLE_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_PRINTABLE_STRING},
+    {SEC_ASN1_IA5_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_IA5_STRING},
+    {SEC_ASN1_T61_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_T61_STRING},
+    {SEC_ASN1_UTF8_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_PKIX_UTF8_STRING},
+    {SEC_ASN1_BMP_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_PKIX_BMP_STRING},
+    {SEC_ASN1_UNIVERSAL_STRING, offsetof(CSSM_X509_TYPE_VALUE_PAIR, value), 0,
+     BER_TAG_PKIX_UNIVERSAL_STRING},
+    {
+     0,
+    }};
 
 const SecAsn1Template kKeyValuePairTemplate[] = {
-  { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CSSM_X509_TYPE_VALUE_PAIR) },
-  { SEC_ASN1_OBJECT_ID, offsetof(CSSM_X509_TYPE_VALUE_PAIR, type), },
-  { SEC_ASN1_INLINE, 0, &kStringValueTemplate, },
-  { 0, }
-};
+    {SEC_ASN1_SEQUENCE, 0, NULL, sizeof(CSSM_X509_TYPE_VALUE_PAIR)},
+    {
+     SEC_ASN1_OBJECT_ID, offsetof(CSSM_X509_TYPE_VALUE_PAIR, type),
+    },
+    {
+     SEC_ASN1_INLINE, 0, &kStringValueTemplate,
+    },
+    {
+     0,
+    }};
 
 struct KeyValuePairs {
   CSSM_X509_TYPE_VALUE_PAIR* pairs;
 };
 
 const SecAsn1Template kKeyValuePairSetTemplate[] = {
-  { SEC_ASN1_SET_OF, offsetof(KeyValuePairs, pairs),
-      kKeyValuePairTemplate, sizeof(KeyValuePairs) }
-};
+    {SEC_ASN1_SET_OF, offsetof(KeyValuePairs, pairs), kKeyValuePairTemplate,
+     sizeof(KeyValuePairs)}};
 
 struct X509Name {
   KeyValuePairs** pairs_list;
 };
 
 const SecAsn1Template kNameTemplate[] = {
-  { SEC_ASN1_SEQUENCE_OF, offsetof(X509Name, pairs_list),
-      kKeyValuePairSetTemplate, sizeof(X509Name) }
-};
+    {SEC_ASN1_SEQUENCE_OF, offsetof(X509Name, pairs_list),
+     kKeyValuePairSetTemplate, sizeof(X509Name)}};
 
 // Converts raw CSSM_DATA to a std::string. (Char encoding is unaltered.)
 std::string DataToString(CSSM_DATA data) {
-  return std::string(
-      reinterpret_cast<std::string::value_type*>(data.Data),
-      data.Length);
+  return std::string(reinterpret_cast<std::string::value_type*>(data.Data),
+                     data.Length);
 }
 
 // Converts raw CSSM_DATA in ISO-8859-1 to a std::string in UTF-8.
@@ -122,7 +114,8 @@ std::string Latin1DataToUTF8String(CSSM_DATA data) {
 
 // Converts big-endian UTF-16 to UTF-8 in a std::string.
 // Note: The byte-order flipping is done in place on the input buffer!
-bool UTF16BigEndianToUTF8(base::char16* chars, size_t length,
+bool UTF16BigEndianToUTF8(base::char16* chars,
+                          size_t length,
                           std::string* out_string) {
   for (size_t i = 0; i < length; i++)
     chars[i] = EndianU16_BtoN(chars[i]);
@@ -131,13 +124,14 @@ bool UTF16BigEndianToUTF8(base::char16* chars, size_t length,
 
 // Converts big-endian UTF-32 to UTF-8 in a std::string.
 // Note: The byte-order flipping is done in place on the input buffer!
-bool UTF32BigEndianToUTF8(int32_t* chars, size_t length,
+bool UTF32BigEndianToUTF8(int32_t* chars,
+                          size_t length,
                           std::string* out_string) {
   for (size_t i = 0; i < length; ++i)
     chars[i] = EndianS32_BtoN(chars[i]);
 #if defined(WCHAR_T_IS_UTF32)
-  return base::WideToUTF8(reinterpret_cast<const wchar_t*>(chars),
-                          length, out_string);
+  return base::WideToUTF8(
+      reinterpret_cast<const wchar_t*>(chars), length, out_string);
 #else
 #error This code doesn't handle 16-bit wchar_t.
 #endif
@@ -182,7 +176,7 @@ bool match(const std::vector<std::string>& rdn1,
     unsigned i2;
     for (i2 = 0; i2 < rdn2.size(); ++i2) {
       if (match(rdn1[i1], rdn2[i2]))
-          break;
+        break;
     }
     if (i2 == rdn2.size())
       return false;
@@ -201,8 +195,8 @@ bool CertPrincipal::ParseDistinguishedName(const void* ber_name_data,
   SecAsn1CoderCreate(&coder);
   DCHECK(coder);
   X509Name* name = NULL;
-  OSStatus err = SecAsn1Decode(coder, ber_name_data, length, kNameTemplate,
-                               &name);
+  OSStatus err =
+      SecAsn1Decode(coder, ber_name_data, length, kNameTemplate, &name);
   if (err) {
     OSSTATUS_LOG(ERROR, err) << "SecAsn1Decode";
     SecAsn1CoderRelease(coder);
@@ -215,13 +209,10 @@ bool CertPrincipal::ParseDistinguishedName(const void* ber_name_data,
   std::vector<std::string> common_names, locality_names, state_names,
       country_names;
   std::vector<std::string>* values[] = {
-      &common_names, &locality_names,
-      &state_names, &country_names,
-      &this->street_addresses,
-      &this->organization_names,
-      &this->organization_unit_names,
-      &this->domain_components
-  };
+      &common_names,                  &locality_names,
+      &state_names,                   &country_names,
+      &this->street_addresses,        &this->organization_names,
+      &this->organization_unit_names, &this->domain_components};
   DCHECK(arraysize(kOIDs) == arraysize(values));
 
   for (int rdn = 0; name[rdn].pairs_list; ++rdn) {
@@ -230,17 +221,16 @@ bool CertPrincipal::ParseDistinguishedName(const void* ber_name_data,
          NULL != (pair = name[rdn].pairs_list[0][pair_index].pairs);
          ++pair_index) {
       switch (pair->valueType) {
-        case BER_TAG_IA5_STRING:          // ASCII (that means 7-bit!)
-        case BER_TAG_PRINTABLE_STRING:    // a subset of ASCII
-        case BER_TAG_PKIX_UTF8_STRING:    // UTF-8
+        case BER_TAG_IA5_STRING:        // ASCII (that means 7-bit!)
+        case BER_TAG_PRINTABLE_STRING:  // a subset of ASCII
+        case BER_TAG_PKIX_UTF8_STRING:  // UTF-8
           AddTypeValuePair(pair->type, DataToString(pair->value), values);
           break;
-        case BER_TAG_T61_STRING:          // T61, pretend it's Latin-1
-          AddTypeValuePair(pair->type,
-                           Latin1DataToUTF8String(pair->value),
-                           values);
+        case BER_TAG_T61_STRING:  // T61, pretend it's Latin-1
+          AddTypeValuePair(
+              pair->type, Latin1DataToUTF8String(pair->value), values);
           break;
-        case BER_TAG_PKIX_BMP_STRING: {        // UTF-16, big-endian
+        case BER_TAG_PKIX_BMP_STRING: {  // UTF-16, big-endian
           std::string value;
           UTF16BigEndianToUTF8(
               reinterpret_cast<base::char16*>(pair->value.Data),
@@ -280,13 +270,13 @@ bool CertPrincipal::ParseDistinguishedName(const void* ber_name_data,
 
 bool CertPrincipal::Matches(const CertPrincipal& against) const {
   return match(common_name, against.common_name) &&
-      match(locality_name, against.locality_name) &&
-      match(state_or_province_name, against.state_or_province_name) &&
-      match(country_name, against.country_name) &&
-      match(street_addresses, against.street_addresses) &&
-      match(organization_names, against.organization_names) &&
-      match(organization_unit_names, against.organization_unit_names) &&
-      match(domain_components, against.domain_components);
+         match(locality_name, against.locality_name) &&
+         match(state_or_province_name, against.state_or_province_name) &&
+         match(country_name, against.country_name) &&
+         match(street_addresses, against.street_addresses) &&
+         match(organization_names, against.organization_names) &&
+         match(organization_unit_names, against.organization_unit_names) &&
+         match(domain_components, against.domain_components);
 }
 
 }  // namespace net