Clang format slam.

net/cert/x509_certificate.h

 // 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.
 
 #ifndef NET_CERT_X509_CERTIFICATE_H_
 #define NET_CERT_X509_CERTIFICATE_H_
 
 #include <string.h>
 
 #include <string>
@@ skipping 33 matching lines @@
 
 typedef std::vector<scoped_refptr<X509Certificate> > CertificateList;
 
 // X509Certificate represents a X.509 certificate, which is comprised a
 // particular identity or end-entity certificate, such as an SSL server
 // identity or an SSL client certificate, and zero or more intermediate
 // certificates that may be used to build a path to a root certificate.
 class NET_EXPORT X509Certificate
     : public base::RefCountedThreadSafe<X509Certificate> {
  public:
-  // An OSCertHandle is a handle to a certificate object in the underlying
-  // crypto library. We assume that OSCertHandle is a pointer type on all
-  // platforms and that NULL represents an invalid OSCertHandle.
+// An OSCertHandle is a handle to a certificate object in the underlying
+// crypto library. We assume that OSCertHandle is a pointer type on all
+// platforms and that NULL represents an invalid OSCertHandle.
 #if defined(OS_WIN)
   typedef PCCERT_CONTEXT OSCertHandle;
 #elif defined(OS_MACOSX)
   typedef SecCertificateRef OSCertHandle;
 #elif defined(USE_OPENSSL_CERTS)
   typedef X509* OSCertHandle;
 #elif defined(USE_NSS)
   typedef struct CERTCertificateStr* OSCertHandle;
 #else
   // TODO(ericroman): not implemented
@@ skipping 29 matching lines @@
     // All PEM blocks will be parsed, until the first error is encountered.
     FORMAT_PEM_CERT_SEQUENCE = 1 << 1,
 
     // The data contains a PKCS#7 SignedData structure, whose certificates
     // member is to be used to initialize the certificate and intermediates.
     // The data may further be encoded using PEM, specifying block names of
     // either "PKCS7" or "CERTIFICATE".
     FORMAT_PKCS7 = 1 << 2,
 
     // Automatically detect the format.
-    FORMAT_AUTO = FORMAT_SINGLE_CERTIFICATE | FORMAT_PEM_CERT_SEQUENCE |
-                  FORMAT_PKCS7,
+    FORMAT_AUTO =
+        FORMAT_SINGLE_CERTIFICATE | FORMAT_PEM_CERT_SEQUENCE | FORMAT_PKCS7,
   };
 
   // PickleType is intended for deserializing certificates that were pickled
   // by previous releases as part of a net::HttpResponseInfo.
   // When serializing certificates to a new Pickle,
   // PICKLETYPE_CERTIFICATE_CHAIN_V3 is always used.
   enum PickleType {
     // When reading a certificate from a Pickle, the Pickle only contains a
     // single certificate.
     PICKLETYPE_SINGLE_CERTIFICATE,
 
     // When reading a certificate from a Pickle, the Pickle contains the
     // the certificate plus any certificates that were stored in
     // |intermediate_ca_certificates_| at the time it was serialized.
     // The count of certificates is stored as a size_t, which is either 32
     // or 64 bits.
     PICKLETYPE_CERTIFICATE_CHAIN_V2,
 
     // The Pickle contains the certificate and any certificates that were
     // stored in |intermediate_ca_certs_| at the time it was serialized.
     // The format is [int count], [data - this certificate],
     // [data - intermediate1], ... [data - intermediateN].
     // All certificates are stored in DER form.
     PICKLETYPE_CERTIFICATE_CHAIN_V3,
   };
 
   // Creates a X509Certificate from the ground up.  Used by tests that simulate
   // SSL connections.
-  X509Certificate(const std::string& subject, const std::string& issuer,
-                  base::Time start_date, base::Time expiration_date);
+  X509Certificate(const std::string& subject,
+                  const std::string& issuer,
+                  base::Time start_date,
+                  base::Time expiration_date);
 
   // Create an X509Certificate from a handle to the certificate object in the
   // underlying crypto library. The returned pointer must be stored in a
   // scoped_refptr<X509Certificate>.
   static X509Certificate* CreateFromHandle(OSCertHandle cert_handle,
                                            const OSCertHandles& intermediates);
 
   // Create an X509Certificate from a chain of DER encoded certificates. The
   // first certificate in the chain is the end-entity certificate to which a
   // handle is returned. The other certificates in the chain are intermediate
@@ skipping 63 matching lines @@
   // the |valid_expiry| date.
   // If we were unable to parse either date from the certificate (or if the cert
   // lacks either date), the date will be null (i.e., is_null() will be true).
   const base::Time& valid_start() const { return valid_start_; }
   const base::Time& valid_expiry() const { return valid_expiry_; }
 
   // The fingerprint of this certificate.
   const SHA1HashValue& fingerprint() const { return fingerprint_; }
 
   // The fingerprint of the intermediate CA certificates.
-  const SHA1HashValue& ca_fingerprint() const {
-    return ca_fingerprint_;
-  }
+  const SHA1HashValue& ca_fingerprint() const { return ca_fingerprint_; }
 
   // Gets the DNS names in the certificate.  Pursuant to RFC 2818, Section 3.1
   // Server Identity, if the certificate has a subjectAltName extension of
   // type dNSName, this method gets the DNS names in that extension.
   // Otherwise, it gets the common name in the subject field.
   void GetDNSNames(std::vector<std::string>* dns_names) const;
 
   // Gets the subjectAltName extension field from the certificate, if any.
   // For future extension; currently this only returns those name types that
   // are required for HTTP certificate name verification - see VerifyHostname.
@@ skipping 80 matching lines @@
   // Does not verify that the certificate is valid, only that the certificate
   // matches this host.
   // Returns true if it matches, and updates |*common_name_fallback_used|,
   // setting it to true if a fallback to the CN was used, rather than
   // subjectAltName.
   bool VerifyNameMatch(const std::string& hostname,
                        bool* common_name_fallback_used) const;
 
   // Obtains the DER encoded certificate data for |cert_handle|. On success,
   // returns true and writes the DER encoded certificate to |*der_encoded|.
-  static bool GetDEREncoded(OSCertHandle cert_handle,
-                            std::string* der_encoded);
+  static bool GetDEREncoded(OSCertHandle cert_handle, std::string* der_encoded);
 
   // Returns the PEM encoded data from a DER encoded certificate. If the return
   // value is true, then the PEM encoded certificate is written to
   // |pem_encoded|.
   static bool GetPEMEncodedFromDER(const std::string& der_encoded,
                                    std::string* pem_encoded);
 
   // Returns the PEM encoded data from an OSCertHandle. If the return value is
   // true, then the PEM encoded certificate is written to |pem_encoded|.
-  static bool GetPEMEncoded(OSCertHandle cert_handle,
-                            std::string* pem_encoded);
+  static bool GetPEMEncoded(OSCertHandle cert_handle, std::string* pem_encoded);
 
   // Encodes the entire certificate chain (this certificate and any
   // intermediate certificates stored in |intermediate_ca_certs_|) as a series
   // of PEM encoded strings. Returns true if all certificates were encoded,
   // storig the result in |*pem_encoded|, with this certificate stored as
   // the first element.
   bool GetPEMEncodedChain(std::vector<std::string>* pem_encoded) const;
 
   // Sets |*size_bits| to be the length of the public key in bits, and sets
   // |*type| to one of the |PublicKeyType| values. In case of
   // |kPublicKeyTypeUnknown|, |*size_bits| will be set to 0.
   static void GetPublicKeyInfo(OSCertHandle cert_handle,
                                size_t* size_bits,
                                PublicKeyType* type);
 
   // Returns the OSCertHandle of this object. Because of caching, this may
   // differ from the OSCertHandle originally supplied during initialization.
   // Note: On Windows, CryptoAPI may return unexpected results if this handle
   // is used across multiple threads. For more details, see
   // CreateOSCertChainForCert().
   OSCertHandle os_cert_handle() const { return cert_handle_; }
 
   // Returns true if two OSCertHandles refer to identical certificates.
   static bool IsSameOSCert(OSCertHandle a, OSCertHandle b);
 
   // Creates an OS certificate handle from the DER-encoded representation.
   // Returns NULL on failure.
-  static OSCertHandle CreateOSCertHandleFromBytes(const char* data,
-                                                  int length);
+  static OSCertHandle CreateOSCertHandleFromBytes(const char* data, int length);
 
 #if defined(USE_NSS)
   // Creates an OS certificate handle from the DER-encoded representation.
   // Returns NULL on failure.  Sets the default nickname if |nickname| is
   // non-NULL.
   static OSCertHandle CreateOSCertHandleFromBytesWithNickname(
       const char* data,
       int length,
       const char* nickname);
 #endif
 
   // Creates all possible OS certificate handles from |data| encoded in a
   // specific |format|. Returns an empty collection on failure.
-  static OSCertHandles CreateOSCertHandlesFromBytes(
-      const char* data,
-      int length,
-      Format format);
+  static OSCertHandles CreateOSCertHandlesFromBytes(const char* data,
+                                                    int length,
+                                                    Format format);
 
   // Duplicates (or adds a reference to) an OS certificate handle.
   static OSCertHandle DupOSCertHandle(OSCertHandle cert_handle);
 
   // Frees (or releases a reference to) an OS certificate handle.
   static void FreeOSCertHandle(OSCertHandle cert_handle);
 
   // Calculates the SHA-1 fingerprint of the certificate.  Returns an empty
   // (all zero) fingerprint on failure.
   static SHA1HashValue CalculateFingerprint(OSCertHandle cert_handle);
 
   // Calculates the SHA-1 fingerprint of the intermediate CA certificates.
   // Returns an empty (all zero) fingerprint on failure.
   static SHA1HashValue CalculateCAFingerprint(
       const OSCertHandles& intermediates);
 
  private:
   friend class base::RefCountedThreadSafe<X509Certificate>;
   friend class TestRootCerts;  // For unit tests
 
   FRIEND_TEST_ALL_PREFIXES(X509CertificateNameVerifyTest, VerifyHostname);
   FRIEND_TEST_ALL_PREFIXES(X509CertificateTest, SerialNumbers);
 
   // Construct an X509Certificate from a handle to the certificate object
   // in the underlying crypto library.
-  X509Certificate(OSCertHandle cert_handle,
-                  const OSCertHandles& intermediates);
+  X509Certificate(OSCertHandle cert_handle, const OSCertHandles& intermediates);
 
   ~X509Certificate();
 
   // Common object initialization code.  Called by the constructors only.
   void Initialize();
 
 #if defined(USE_OPENSSL_CERTS)
   // Resets the store returned by cert_store() to default state. Used by
   // TestRootCerts to undo modifications.
   static void ResetCertStore();
@@ skipping 65 matching lines @@
   // based on the type of the certificate.
   std::string default_nickname_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(X509Certificate);
 };
 
 }  // namespace net
 
 #endif  // NET_CERT_X509_CERTIFICATE_H_