Clang format slam.

net/socket/ssl_server_socket_nss.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/socket/ssl_server_socket_nss.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #endif
 
@@ skipping 144 matching lines @@
 }
 
 int SSLServerSocketNSS::ExportKeyingMaterial(const base::StringPiece& label,
                                              bool has_context,
                                              const base::StringPiece& context,
                                              unsigned char* out,
                                              unsigned int outlen) {
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
   SECStatus result = SSL_ExportKeyingMaterial(
-      nss_fd_, label.data(), label.size(), has_context,
+      nss_fd_,
+      label.data(),
+      label.size(),
+      has_context,
       reinterpret_cast<const unsigned char*>(context.data()),
-      context.length(), out, outlen);
+      context.length(),
+      out,
+      outlen);
   if (result != SECSuccess) {
     LogFailedNSSFunction(net_log_, "SSL_ExportKeyingMaterial", "");
     return MapNSSError(PORT_GetError());
   }
   return OK;
 }
 
 int SSLServerSocketNSS::GetTLSUniqueChannelBinding(std::string* out) {
   if (!IsConnected())
     return ERR_SOCKET_NOT_CONNECTED;
   unsigned char buf[64];
   unsigned int len;
-  SECStatus result = SSL_GetChannelBinding(nss_fd_,
-                                           SSL_CHANNEL_BINDING_TLS_UNIQUE,
-                                           buf, &len, arraysize(buf));
+  SECStatus result = SSL_GetChannelBinding(
+      nss_fd_, SSL_CHANNEL_BINDING_TLS_UNIQUE, buf, &len, arraysize(buf));
   if (result != SECSuccess) {
     LogFailedNSSFunction(net_log_, "SSL_GetChannelBinding", "");
     return MapNSSError(PORT_GetError());
   }
   out->assign(reinterpret_cast<char*>(buf), len);
   return OK;
 }
 
 int SSLServerSocketNSS::Connect(const CompletionCallback& callback) {
   NOTIMPLEMENTED();
   return ERR_NOT_IMPLEMENTED;
 }
 
-int SSLServerSocketNSS::Read(IOBuffer* buf, int buf_len,
+int SSLServerSocketNSS::Read(IOBuffer* buf,
+                             int buf_len,
                              const CompletionCallback& callback) {
   DCHECK(user_read_callback_.is_null());
   DCHECK(user_handshake_callback_.is_null());
   DCHECK(!user_read_buf_.get());
   DCHECK(nss_bufs_);
   DCHECK(!callback.is_null());
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
 
   DCHECK(completed_handshake_);
 
   int rv = DoReadLoop(OK);
 
   if (rv == ERR_IO_PENDING) {
     user_read_callback_ = callback;
   } else {
     user_read_buf_ = NULL;
     user_read_buf_len_ = 0;
   }
   return rv;
 }
 
-int SSLServerSocketNSS::Write(IOBuffer* buf, int buf_len,
+int SSLServerSocketNSS::Write(IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) {
   DCHECK(user_write_callback_.is_null());
   DCHECK(!user_write_buf_.get());
   DCHECK(nss_bufs_);
   DCHECK(!callback.is_null());
 
   user_write_buf_ = buf;
   user_write_buf_len_ = buf_len;
 
   int rv = DoWriteLoop(OK);
@@ skipping 127 matching lines @@
           SECSuccess) {
         if (strcmp(info.keaTypeName, "ECDHE") != 0) {
           SSL_CipherPrefSet(nss_fd_, ssl_ciphers[i], PR_FALSE);
         }
       }
     }
   }
 
   for (std::vector<uint16>::const_iterator it =
            ssl_config_.disabled_cipher_suites.begin();
-       it != ssl_config_.disabled_cipher_suites.end(); ++it) {
+       it != ssl_config_.disabled_cipher_suites.end();
+       ++it) {
     // This will fail if the specified cipher is not implemented by NSS, but
     // the failure is harmless.
     SSL_CipherPrefSet(nss_fd_, *it, PR_FALSE);
   }
 
   // Server socket doesn't need session tickets.
   rv = SSL_OptionSet(nss_fd_, SSL_ENABLE_SESSION_TICKETS, PR_FALSE);
   if (rv != SECSuccess) {
     LogFailedNSSFunction(
         net_log_, "SSL_OptionSet", "SSL_ENABLE_SESSION_TICKETS");
@@ skipping 35 matching lines @@
     LogFailedNSSFunction(net_log_, "SSL_HandshakeCallback", "");
     return ERR_UNEXPECTED;
   }
 
   // Get a certificate of CERTCertificate structure.
   std::string der_string;
   if (!X509Certificate::GetDEREncoded(cert_->os_cert_handle(), &der_string))
     return ERR_UNEXPECTED;
 
   SECItem der_cert;
-  der_cert.data = reinterpret_cast<unsigned char*>(const_cast<char*>(
-      der_string.data()));
-  der_cert.len  = der_string.length();
+  der_cert.data =
+      reinterpret_cast<unsigned char*>(const_cast<char*>(der_string.data()));
+  der_cert.len = der_string.length();
   der_cert.type = siDERCertBuffer;
 
   // Parse into a CERTCertificate structure.
   CERTCertificate* cert = CERT_NewTempCertificate(
       CERT_GetDefaultCertDB(), &der_cert, NULL, PR_FALSE, PR_TRUE);
   if (!cert) {
     LogFailedNSSFunction(net_log_, "CERT_NewTempCertificate", "");
     return MapNSSError(PORT_GetError());
   }
 
   // Get a key of SECKEYPrivateKey* structure.
   std::vector<uint8> key_vector;
   if (!key_->ExportPrivateKey(&key_vector)) {
     CERT_DestroyCertificate(cert);
     return ERR_UNEXPECTED;
   }
 
   SECKEYPrivateKeyStr* private_key = NULL;
   PK11SlotInfo* slot = crypto::GetPrivateNSSKeySlot();
   if (!slot) {
     CERT_DestroyCertificate(cert);
     return ERR_UNEXPECTED;
   }
 
   SECItem der_private_key_info;
-  der_private_key_info.data =
-      const_cast<unsigned char*>(&key_vector.front());
+  der_private_key_info.data = const_cast<unsigned char*>(&key_vector.front());
   der_private_key_info.len = key_vector.size();
   // The server's RSA private key must be imported into NSS with the
   // following key usage bits:
   // - KU_KEY_ENCIPHERMENT, required for the RSA key exchange algorithm.
   // - KU_DIGITAL_SIGNATURE, required for the DHE_RSA and ECDHE_RSA key
   //   exchange algorithms.
   const unsigned int key_usage = KU_KEY_ENCIPHERMENT | KU_DIGITAL_SIGNATURE;
-  rv =  PK11_ImportDERPrivateKeyInfoAndReturnKey(
-      slot, &der_private_key_info, NULL, NULL, PR_FALSE, PR_FALSE,
-      key_usage, &private_key, NULL);
+  rv = PK11_ImportDERPrivateKeyInfoAndReturnKey(slot,
+                                                &der_private_key_info,
+                                                NULL,
+                                                NULL,
+                                                PR_FALSE,
+                                                PR_FALSE,
+                                                key_usage,
+                                                &private_key,
+                                                NULL);
   PK11_FreeSlot(slot);
   if (rv != SECSuccess) {
     CERT_DestroyCertificate(cert);
     return ERR_UNEXPECTED;
   }
 
   // Assign server certificate and private key.
   SSLKEAType cert_kea = NSS_FindCertKEAType(cert);
   rv = SSL_ConfigSecureServer(nss_fd_, cert, private_key, cert_kea);
   CERT_DestroyCertificate(cert);
@@ skipping 95 matching lines @@
   return rv;
 }
 
 void SSLServerSocketNSS::BufferSendComplete(int result) {
   memio_PutWriteResult(nss_bufs_, MapErrorToNSS(result));
   transport_send_busy_ = false;
   OnSendComplete(result);
 }
 
 int SSLServerSocketNSS::BufferRecv(void) {
-  if (transport_recv_busy_) return ERR_IO_PENDING;
+  if (transport_recv_busy_)
+    return ERR_IO_PENDING;
 
   char* buf;
   int nb = memio_GetReadParams(nss_bufs_, &buf);
   int rv;
   if (!nb) {
     // buffer too full to read into, so no I/O possible at moment
     rv = ERR_IO_PENDING;
   } else {
     recv_buffer_ = new IOBuffer(nb);
     rv = transport_socket_->Read(
@@ skipping 225 matching lines @@
                                                  PRBool checksig,
                                                  PRBool is_server) {
   // TODO(hclam): Implement.
   // Tell NSS to not verify the certificate.
   return SECSuccess;
 }
 
 // static
 // NSS calls this when handshake is completed.
 // After the SSL handshake is finished we need to verify the certificate.
-void SSLServerSocketNSS::HandshakeCallback(PRFileDesc* socket,
-                                           void* arg) {
+void SSLServerSocketNSS::HandshakeCallback(PRFileDesc* socket, void* arg) {
   // TODO(hclam): Implement.
 }
 
 int SSLServerSocketNSS::Init() {
   // Initialize the NSS SSL library in a threadsafe way.  This also
   // initializes the NSS base library.
   EnsureNSSSSLInit();
   if (!NSS_IsInitialized())
     return ERR_UNEXPECTED;
 
   EnableSSLServerSockets();
   return OK;
 }
 
 }  // namespace net