Clang format slam.

net/test/spawned_test_server/base_test_server.cc

 // Copyright 2013 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/test/spawned_test_server/base_test_server.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 53 matching lines @@
     : server_certificate(CERT_OK),
       ocsp_status(OCSP_OK),
       cert_serial(0),
       request_client_certificate(false),
       key_exchanges(SSLOptions::KEY_EXCHANGE_ANY),
       bulk_ciphers(SSLOptions::BULK_CIPHER_ANY),
       record_resume(false),
       tls_intolerant(TLS_INTOLERANT_NONE),
       fallback_scsv_enabled(false),
       staple_ocsp_response(false),
-      enable_npn(false) {}
+      enable_npn(false) {
+}
 
 BaseTestServer::SSLOptions::SSLOptions(
     BaseTestServer::SSLOptions::ServerCertificate cert)
     : server_certificate(cert),
       ocsp_status(OCSP_OK),
       cert_serial(0),
       request_client_certificate(false),
       key_exchanges(SSLOptions::KEY_EXCHANGE_ANY),
       bulk_ciphers(SSLOptions::BULK_CIPHER_ANY),
       record_resume(false),
       tls_intolerant(TLS_INTOLERANT_NONE),
       fallback_scsv_enabled(false),
       staple_ocsp_response(false),
-      enable_npn(false) {}
+      enable_npn(false) {
+}
 
-BaseTestServer::SSLOptions::~SSLOptions() {}
+BaseTestServer::SSLOptions::~SSLOptions() {
+}
 
 base::FilePath BaseTestServer::SSLOptions::GetCertificateFile() const {
   switch (server_certificate) {
     case CERT_OK:
     case CERT_MISMATCHED_NAME:
       return base::FilePath(FILE_PATH_LITERAL("ok_cert.pem"));
     case CERT_EXPIRED:
       return base::FilePath(FILE_PATH_LITERAL("expired_cert.pem"));
     case CERT_CHAIN_WRONG_ROOT:
       // This chain uses its own dedicated test root certificate to avoid
@@ skipping 24 matching lines @@
       return "unknown";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 const char BaseTestServer::kLocalhost[] = "127.0.0.1";
 
 BaseTestServer::BaseTestServer(Type type, const std::string& host)
-    : type_(type),
-      started_(false),
-      log_to_console_(false) {
+    : type_(type), started_(false), log_to_console_(false) {
   Init(host);
 }
 
 BaseTestServer::BaseTestServer(Type type, const SSLOptions& ssl_options)
     : ssl_options_(ssl_options),
       type_(type),
       started_(false),
       log_to_console_(false) {
   DCHECK(UsingSSL(type));
   Init(GetHostname(type, ssl_options));
 }
 
-BaseTestServer::~BaseTestServer() {}
+BaseTestServer::~BaseTestServer() {
+}
 
 const HostPortPair& BaseTestServer::host_port_pair() const {
   DCHECK(started_);
   return host_port_pair_;
 }
 
 const base::DictionaryValue& BaseTestServer::server_data() const {
   DCHECK(started_);
   DCHECK(server_data_.get());
   return *server_data_;
@@ skipping 46 matching lines @@
 
 void BaseTestServer::SetPort(uint16 port) {
   host_port_pair_.set_port(port);
 }
 
 GURL BaseTestServer::GetURL(const std::string& path) const {
   return GURL(GetScheme() + "://" + host_port_pair_.ToString() + "/" + path);
 }
 
 GURL BaseTestServer::GetURLWithUser(const std::string& path,
-                                const std::string& user) const {
+                                    const std::string& user) const {
   return GURL(GetScheme() + "://" + user + "@" + host_port_pair_.ToString() +
               "/" + path);
 }
 
-GURL BaseTestServer::GetURLWithUserAndPassword(const std::string& path,
-                                           const std::string& user,
-                                           const std::string& password) const {
+GURL BaseTestServer::GetURLWithUserAndPassword(
+    const std::string& path,
+    const std::string& user,
+    const std::string& password) const {
   return GURL(GetScheme() + "://" + user + ":" + password + "@" +
               host_port_pair_.ToString() + "/" + path);
 }
 
 // static
 bool BaseTestServer::GetFilePathWithReplacements(
     const std::string& original_file_path,
     const std::vector<StringPair>& text_to_replace,
     std::string* replacement_path) {
   std::string new_file_path = original_file_path;
@@ skipping 81 matching lines @@
   }
 
   return root_certs->AddFromFile(
       root_certificate_path.AppendASCII("root_ca_cert.pem"));
 }
 
 bool BaseTestServer::SetupWhenServerStarted() {
   DCHECK(host_port_pair_.port());
 
   if (UsingSSL(type_) && !LoadTestRootCert())
-      return false;
+    return false;
 
   started_ = true;
   allowed_port_.reset(new ScopedPortException(host_port_pair_.port()));
   return true;
 }
 
 void BaseTestServer::CleanUpWhenStoppingServer() {
   TestRootCerts* root_certs = TestRootCerts::GetInstance();
   root_certs->Clear();
 
@@ skipping 31 matching lines @@
       arguments->SetString("cert-and-key-file", certificate_path.value());
     }
 
     // Check the client certificate related arguments.
     if (ssl_options_.request_client_certificate)
       arguments->Set("ssl-client-auth", base::Value::CreateNullValue());
     scoped_ptr<base::ListValue> ssl_client_certs(new base::ListValue());
 
     std::vector<base::FilePath>::const_iterator it;
     for (it = ssl_options_.client_authorities.begin();
-         it != ssl_options_.client_authorities.end(); ++it) {
+         it != ssl_options_.client_authorities.end();
+         ++it) {
       if (it->IsAbsolute() && !base::PathExists(*it)) {
         LOG(ERROR) << "Client authority path " << it->value()
                    << " doesn't exist. Can't launch https server.";
         return false;
       }
       ssl_client_certs->Append(new base::StringValue(it->value()));
     }
 
     if (ssl_client_certs->GetSize())
       arguments->Set("ssl-client-ca", ssl_client_certs.release());
@@ skipping 43 matching lines @@
 
   return GenerateAdditionalArguments(arguments);
 }
 
 bool BaseTestServer::GenerateAdditionalArguments(
     base::DictionaryValue* arguments) const {
   return true;
 }
 
 }  // namespace net