Clang format slam.

net/ssl/server_bound_cert_service.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/ssl/server_bound_cert_service.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 52 matching lines @@
   // We don't support any of the cert types the server requested.
   UNSUPPORTED_TYPE = 8,
   // Server asked for a different type of certs while we were generating one.
   TYPE_MISMATCH = 9,
   // Couldn't start a worker to generate a cert.
   WORKER_FAILURE = 10,
   GET_CERT_RESULT_MAX
 };
 
 void RecordGetDomainBoundCertResult(GetCertResult result) {
-  UMA_HISTOGRAM_ENUMERATION("DomainBoundCerts.GetDomainBoundCertResult", result,
-                            GET_CERT_RESULT_MAX);
+  UMA_HISTOGRAM_ENUMERATION(
+      "DomainBoundCerts.GetDomainBoundCertResult", result, GET_CERT_RESULT_MAX);
 }
 
 void RecordGetCertTime(base::TimeDelta request_time) {
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.GetCertTime",
                              request_time,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(5),
                              50);
 }
 
@@ skipping 18 matching lines @@
                                                 serial_number,
                                                 not_valid_before,
                                                 not_valid_after,
                                                 &key,
                                                 &der_cert)) {
     DLOG(ERROR) << "Unable to create x509 cert for client";
     *error = ERR_ORIGIN_BOUND_CERT_GENERATION_FAILED;
     return result.Pass();
   }
 
-  if (!key->ExportEncryptedPrivateKey(ServerBoundCertService::kEPKIPassword,
-                                      1, &private_key_info)) {
+  if (!key->ExportEncryptedPrivateKey(
+          ServerBoundCertService::kEPKIPassword, 1, &private_key_info)) {
     DLOG(ERROR) << "Unable to export private key";
     *error = ERR_PRIVATE_KEY_EXPORT_FAILED;
     return result.Pass();
   }
 
   // TODO(rkn): Perhaps ExportPrivateKey should be changed to output a
   // std::string* to prevent this copying.
   std::string key_out(private_key_info.begin(), private_key_info.end());
 
   result.reset(new ServerBoundCertStore::ServerBoundCert(
-      server_identifier,
-      not_valid_before,
-      not_valid_after,
-      key_out,
-      der_cert));
+      server_identifier, not_valid_before, not_valid_after, key_out, der_cert));
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.GenerateCertTime",
                              base::TimeTicks::Now() - start,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(5),
                              50);
   *error = OK;
   return result.Pass();
 }
 
 }  // namespace
 
 // Represents the output and result callback of a request.
 class ServerBoundCertServiceRequest {
  public:
   ServerBoundCertServiceRequest(base::TimeTicks request_start,
                                 const CompletionCallback& callback,
                                 std::string* private_key,
                                 std::string* cert)
       : request_start_(request_start),
         callback_(callback),
         private_key_(private_key),
-        cert_(cert) {
-  }
+        cert_(cert) {}
 
   // Ensures that the result callback will never be made.
   void Cancel() {
     RecordGetDomainBoundCertResult(ASYNC_CANCELLED);
     callback_.Reset();
     private_key_ = NULL;
     cert_ = NULL;
   }
 
   // Copies the contents of |private_key| and |cert| to the caller's output
@@ skipping 49 matching lines @@
 // ServerBoundCertServiceWorker runs on a worker thread and takes care of the
 // blocking process of performing key generation. Will take care of deleting
 // itself once Start() is called.
 class ServerBoundCertServiceWorker {
  public:
   typedef base::Callback<void(
       const std::string&,
       int,
       scoped_ptr<ServerBoundCertStore::ServerBoundCert>)> WorkerDoneCallback;
 
-  ServerBoundCertServiceWorker(
-      const std::string& server_identifier,
-      const WorkerDoneCallback& callback)
+  ServerBoundCertServiceWorker(const std::string& server_identifier,
+                               const WorkerDoneCallback& callback)
       : server_identifier_(server_identifier),
         serial_number_(base::RandInt(0, std::numeric_limits<int>::max())),
         origin_loop_(base::MessageLoopProxy::current()),
-        callback_(callback) {
-  }
+        callback_(callback) {}
 
   // Starts the worker on |task_runner|. If the worker fails to start, such as
   // if the task runner is shutting down, then it will take care of deleting
   // itself.
   bool Start(const scoped_refptr<base::TaskRunner>& task_runner) {
     DCHECK(origin_loop_->RunsTasksOnCurrentThread());
 
     return task_runner->PostTask(
         FROM_HERE,
         base::Bind(&ServerBoundCertServiceWorker::Run, base::Owned(this)));
   }
 
  private:
   void Run() {
     // Runs on a worker thread.
     int error = ERR_FAILED;
     scoped_ptr<ServerBoundCertStore::ServerBoundCert> cert =
         GenerateCert(server_identifier_, serial_number_, &error);
     DVLOG(1) << "GenerateCert " << server_identifier_ << " returned " << error;
 #if defined(USE_NSS)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
     // the NSPR thread ID in thread-specific data.
     // The threads in our thread pool terminate after we have called
     // PR_Cleanup. Unless we detach them from NSPR, net_unittests gets
     // segfaults on shutdown when the threads' thread-specific data
     // destructors run.
     PR_DetachThread();
 #endif
-    origin_loop_->PostTask(FROM_HERE,
-                           base::Bind(callback_, server_identifier_, error,
-                                      base::Passed(&cert)));
+    origin_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(callback_, server_identifier_, error, base::Passed(&cert)));
   }
 
   const std::string server_identifier_;
   // Note that serial_number_ must be initialized on a non-worker thread
   // (see documentation for GenerateCert).
   uint32 serial_number_;
   scoped_refptr<base::SequencedTaskRunner> origin_loop_;
   WorkerDoneCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerBoundCertServiceWorker);
 };
 
 // A ServerBoundCertServiceJob is a one-to-one counterpart of an
 // ServerBoundCertServiceWorker. It lives only on the ServerBoundCertService's
 // origin message loop.
 class ServerBoundCertServiceJob {
  public:
   ServerBoundCertServiceJob(bool create_if_missing)
-      : create_if_missing_(create_if_missing) {
-  }
+      : create_if_missing_(create_if_missing) {}
 
   ~ServerBoundCertServiceJob() {
     if (!requests_.empty())
       DeleteAllCanceled();
   }
 
   void AddRequest(ServerBoundCertServiceRequest* request,
                   bool create_if_missing = false) {
     create_if_missing_ |= create_if_missing;
     requests_.push_back(request);
   }
 
   void HandleResult(int error,
                     const std::string& private_key,
                     const std::string& cert) {
     PostAll(error, private_key, cert);
   }
 
   bool CreateIfMissing() const { return create_if_missing_; }
 
  private:
   void PostAll(int error,
                const std::string& private_key,
                const std::string& cert) {
     std::vector<ServerBoundCertServiceRequest*> requests;
     requests_.swap(requests);
 
-    for (std::vector<ServerBoundCertServiceRequest*>::iterator
-         i = requests.begin(); i != requests.end(); i++) {
+    for (std::vector<ServerBoundCertServiceRequest*>::iterator i =
+             requests.begin();
+         i != requests.end();
+         i++) {
       (*i)->Post(error, private_key, cert);
       // Post() causes the ServerBoundCertServiceRequest to delete itself.
     }
   }
 
   void DeleteAllCanceled() {
-    for (std::vector<ServerBoundCertServiceRequest*>::iterator
-         i = requests_.begin(); i != requests_.end(); i++) {
+    for (std::vector<ServerBoundCertServiceRequest*>::iterator i =
+             requests_.begin();
+         i != requests_.end();
+         i++) {
       if ((*i)->canceled()) {
         delete *i;
       } else {
         LOG(DFATAL) << "ServerBoundCertServiceRequest leaked!";
       }
     }
   }
 
   std::vector<ServerBoundCertServiceRequest*> requests_;
   bool create_if_missing_;
 };
 
 // static
 const char ServerBoundCertService::kEPKIPassword[] = "";
 
 ServerBoundCertService::RequestHandle::RequestHandle()
-    : service_(NULL),
-      request_(NULL) {}
+    : service_(NULL), request_(NULL) {
+}
 
 ServerBoundCertService::RequestHandle::~RequestHandle() {
   Cancel();
 }
 
 void ServerBoundCertService::RequestHandle::Cancel() {
   if (request_) {
     service_->CancelRequest(request_);
     request_ = NULL;
     callback_.Reset();
@@ skipping 21 matching lines @@
     ServerBoundCertStore* server_bound_cert_store,
     const scoped_refptr<base::TaskRunner>& task_runner)
     : server_bound_cert_store_(server_bound_cert_store),
       task_runner_(task_runner),
       requests_(0),
       cert_store_hits_(0),
       inflight_joins_(0),
       workers_created_(0),
       weak_ptr_factory_(this) {
   base::Time start = base::Time::Now();
-  base::Time end = start + base::TimeDelta::FromDays(
-      kValidityPeriodInDays + kSystemTimeValidityBufferInDays);
+  base::Time end =
+      start + base::TimeDelta::FromDays(kValidityPeriodInDays +
+                                        kSystemTimeValidityBufferInDays);
   is_system_time_valid_ = x509_util::IsSupportedValidityRange(start, end);
 }
 
 ServerBoundCertService::~ServerBoundCertService() {
   STLDeleteValues(&inflight_);
 }
 
-//static
+// static
 std::string ServerBoundCertService::GetDomainForHost(const std::string& host) {
-  std::string domain =
-      registry_controlled_domains::GetDomainAndRegistry(
-          host, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
+  std::string domain = registry_controlled_domains::GetDomainAndRegistry(
+      host, registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   if (domain.empty())
     return host;
   return domain;
 }
 
 int ServerBoundCertService::GetOrCreateDomainBoundCert(
     const std::string& host,
     std::string* private_key,
     std::string* cert,
     const CompletionCallback& callback,
@@ skipping 10 matching lines @@
   std::string domain = GetDomainForHost(host);
   if (domain.empty()) {
     RecordGetDomainBoundCertResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   requests_++;
 
   // See if a request for the same domain is currently in flight.
   bool create_if_missing = true;
-  if (JoinToInFlightRequest(request_start, domain, private_key, cert,
-                            create_if_missing, callback, out_req)) {
+  if (JoinToInFlightRequest(request_start,
+                            domain,
+                            private_key,
+                            cert,
+                            create_if_missing,
+                            callback,
+                            out_req)) {
     return ERR_IO_PENDING;
   }
 
-  int err = LookupDomainBoundCert(request_start, domain, private_key, cert,
-                                  create_if_missing, callback, out_req);
+  int err = LookupDomainBoundCert(request_start,
+                                  domain,
+                                  private_key,
+                                  cert,
+                                  create_if_missing,
+                                  callback,
+                                  out_req);
   if (err == ERR_FILE_NOT_FOUND) {
     // Sync lookup did not find a valid cert.  Start generating a new one.
     workers_created_++;
     ServerBoundCertServiceWorker* worker = new ServerBoundCertServiceWorker(
         domain,
         base::Bind(&ServerBoundCertService::GeneratedServerBoundCert,
                    weak_ptr_factory_.GetWeakPtr()));
     if (!worker->Start(task_runner_)) {
       // TODO(rkn): Log to the NetLog.
       LOG(ERROR) << "ServerBoundCertServiceWorker couldn't be started.";
@@ skipping 37 matching lines @@
   std::string domain = GetDomainForHost(host);
   if (domain.empty()) {
     RecordGetDomainBoundCertResult(INVALID_ARGUMENT);
     return ERR_INVALID_ARGUMENT;
   }
 
   requests_++;
 
   // See if a request for the same domain currently in flight.
   bool create_if_missing = false;
-  if (JoinToInFlightRequest(request_start, domain, private_key, cert,
-                            create_if_missing, callback, out_req)) {
+  if (JoinToInFlightRequest(request_start,
+                            domain,
+                            private_key,
+                            cert,
+                            create_if_missing,
+                            callback,
+                            out_req)) {
     return ERR_IO_PENDING;
   }
 
-  int err = LookupDomainBoundCert(request_start, domain, private_key, cert,
-                                  create_if_missing, callback, out_req);
+  int err = LookupDomainBoundCert(request_start,
+                                  domain,
+                                  private_key,
+                                  cert,
+                                  create_if_missing,
+                                  callback,
+                                  out_req);
   return err;
 }
 
 void ServerBoundCertService::GotServerBoundCert(
     int err,
     const std::string& server_identifier,
     base::Time expiration_time,
     const std::string& key,
     const std::string& cert) {
   DCHECK(CalledOnValidThread());
@@ skipping 46 matching lines @@
 
 void ServerBoundCertService::GeneratedServerBoundCert(
     const std::string& server_identifier,
     int error,
     scoped_ptr<ServerBoundCertStore::ServerBoundCert> cert) {
   DCHECK(CalledOnValidThread());
 
   if (error == OK) {
     // TODO(mattm): we should just Pass() the cert object to
     // SetServerBoundCert().
-    server_bound_cert_store_->SetServerBoundCert(
-        cert->server_identifier(),
-        cert->creation_time(),
-        cert->expiration_time(),
-        cert->private_key(),
-        cert->cert());
+    server_bound_cert_store_->SetServerBoundCert(cert->server_identifier(),
+                                                 cert->creation_time(),
+                                                 cert->expiration_time(),
+                                                 cert->private_key(),
+                                                 cert->cert());
 
     HandleResult(error, server_identifier, cert->private_key(), cert->cert());
   } else {
     HandleResult(error, server_identifier, std::string(), std::string());
   }
 }
 
-void ServerBoundCertService::HandleResult(
-    int error,
-    const std::string& server_identifier,
-    const std::string& private_key,
-    const std::string& cert) {
+void ServerBoundCertService::HandleResult(int error,
+                                          const std::string& server_identifier,
+                                          const std::string& private_key,
+                                          const std::string& cert) {
   DCHECK(CalledOnValidThread());
 
   std::map<std::string, ServerBoundCertServiceJob*>::iterator j;
   j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   ServerBoundCertServiceJob* job = j->second;
   inflight_.erase(j);
@@ skipping 38 matching lines @@
     std::string* private_key,
     std::string* cert,
     bool create_if_missing,
     const CompletionCallback& callback,
     RequestHandle* out_req) {
   // Check if a domain bound cert already exists for this domain. Note that
   // |expiration_time| is ignored, and expired certs are considered valid.
   base::Time expiration_time;
   int err = server_bound_cert_store_->GetServerBoundCert(
       domain,
-      &expiration_time  /* ignored */,
+      &expiration_time /* ignored */,
       private_key,
       cert,
       base::Bind(&ServerBoundCertService::GotServerBoundCert,
                  weak_ptr_factory_.GetWeakPtr()));
 
   if (err == OK) {
     // Sync lookup found a valid cert.
     DVLOG(1) << "Cert store had valid cert for " << domain;
     cert_store_hits_++;
     RecordGetDomainBoundCertResult(SYNC_SUCCESS);
@@ skipping 21 matching lines @@
   }
 
   return err;
 }
 
 int ServerBoundCertService::cert_count() {
   return server_bound_cert_store_->GetCertCount();
 }
 
 }  // namespace net