Clang format slam.

net/ssl/server_bound_cert_service.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_SSL_SERVER_BOUND_CERT_SERVICE_H_
 #define NET_SSL_SERVER_BOUND_CERT_SERVICE_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 56 matching lines @@
   };
 
   // Password used on EncryptedPrivateKeyInfo data stored in EC private_key
   // values.  (This is not used to provide any security, but to workaround NSS
   // being unable to import unencrypted PrivateKeyInfo for EC keys.)
   static const char kEPKIPassword[];
 
   // This object owns |server_bound_cert_store|.  |task_runner| will
   // be used to post certificate generation worker tasks.  The tasks are
   // safe for use with WorkerPool and SequencedWorkerPool::CONTINUE_ON_SHUTDOWN.
-  ServerBoundCertService(
-      ServerBoundCertStore* server_bound_cert_store,
-      const scoped_refptr<base::TaskRunner>& task_runner);
+  ServerBoundCertService(ServerBoundCertStore* server_bound_cert_store,
+                         const scoped_refptr<base::TaskRunner>& task_runner);
 
   ~ServerBoundCertService();
 
   // Returns the domain to be used for |host|.  The domain is the
   // "registry controlled domain", or the "ETLD + 1" where one exists, or
   // the origin otherwise.
   static std::string GetDomainForHost(const std::string& host);
 
   // Tests whether the system time is within the supported range for
   // certificate generation.  This value is cached when ServerBoundCertService
   // is created, so if the system time is changed by a huge amount, this may no
   // longer hold.
   bool IsSystemTimeValid() const { return is_system_time_valid_; }
 
   // Fetches the domain bound cert for the specified host if one exists and
   // creates one otherwise. Returns OK if successful or an error code upon
   // failure.
   //
   // On successful completion, |private_key| stores a DER-encoded
   // PrivateKeyInfo struct, and |cert| stores a DER-encoded certificate.
   // The PrivateKeyInfo is always an ECDSA private key.
   //
   // |callback| must not be null. ERR_IO_PENDING is returned if the operation
   // could not be completed immediately, in which case the result code will
   // be passed to the callback when available.
   //
   // |*out_req| will be initialized with a handle to the async request. This
   // RequestHandle object must be cancelled or destroyed before the
   // ServerBoundCertService is destroyed.
-  int GetOrCreateDomainBoundCert(
-      const std::string& host,
-      std::string* private_key,
-      std::string* cert,
-      const CompletionCallback& callback,
-      RequestHandle* out_req);
+  int GetOrCreateDomainBoundCert(const std::string& host,
+                                 std::string* private_key,
+                                 std::string* cert,
+                                 const CompletionCallback& callback,
+                                 RequestHandle* out_req);
 
   // Fetches the domain bound cert for the specified host if one exists.
   // Returns OK if successful, ERR_FILE_NOT_FOUND if none exists, or an error
   // code upon failure.
   //
   // On successful completion, |private_key| stores a DER-encoded
   // PrivateKeyInfo struct, and |cert| stores a DER-encoded certificate.
   // The PrivateKeyInfo is always an ECDSA private key.
   //
   // |callback| must not be null. ERR_IO_PENDING is returned if the operation
   // could not be completed immediately, in which case the result code will
   // be passed to the callback when available. If an in-flight
   // GetDomainBoundCert is pending, and a new GetOrCreateDomainBoundCert
   // request arrives for the same domain, the GetDomainBoundCert request will
   // not complete until a new cert is created.
   //
   // |*out_req| will be initialized with a handle to the async request. This
   // RequestHandle object must be cancelled or destroyed before the
   // ServerBoundCertService is destroyed.
-  int GetDomainBoundCert(
-      const std::string& host,
-      std::string* private_key,
-      std::string* cert,
-      const CompletionCallback& callback,
-      RequestHandle* out_req);
+  int GetDomainBoundCert(const std::string& host,
+                         std::string* private_key,
+                         std::string* cert,
+                         const CompletionCallback& callback,
+                         RequestHandle* out_req);
 
   // Returns the backing ServerBoundCertStore.
   ServerBoundCertStore* GetCertStore();
 
   // Public only for unit testing.
   int cert_count();
   uint64 requests() const { return requests_; }
   uint64 cert_store_hits() const { return cert_store_hits_; }
   uint64 inflight_joins() const { return inflight_joins_; }
   uint64 workers_created() const { return workers_created_; }
@@ skipping 56 matching lines @@
   bool is_system_time_valid_;
 
   base::WeakPtrFactory<ServerBoundCertService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerBoundCertService);
 };
 
 }  // namespace net
 
 #endif  // NET_SSL_SERVER_BOUND_CERT_SERVICE_H_