Clang format slam.

net/ssl/server_bound_cert_service_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 101 matching lines @@
                                                     err,
                                                     server_identifier_,
                                                     expiration_time,
                                                     private_key,
                                                     cert));
 }
 
 class ServerBoundCertServiceTest : public testing::Test {
  public:
   ServerBoundCertServiceTest()
-      : service_(new ServerBoundCertService(
-            new DefaultServerBoundCertStore(NULL),
-            base::MessageLoopProxy::current())) {
-  }
+      : service_(
+            new ServerBoundCertService(new DefaultServerBoundCertStore(NULL),
+                                       base::MessageLoopProxy::current())) {}
 
  protected:
   scoped_ptr<ServerBoundCertService> service_;
 };
 
 TEST_F(ServerBoundCertServiceTest, GetDomainForHost) {
   EXPECT_EQ("google.com",
             ServerBoundCertService::GetDomainForHost("google.com"));
   EXPECT_EQ("google.com",
             ServerBoundCertService::GetDomainForHost("www.google.com"));
   EXPECT_EQ("foo.appspot.com",
             ServerBoundCertService::GetDomainForHost("foo.appspot.com"));
   EXPECT_EQ("bar.appspot.com",
             ServerBoundCertService::GetDomainForHost("foo.bar.appspot.com"));
   EXPECT_EQ("appspot.com",
             ServerBoundCertService::GetDomainForHost("appspot.com"));
   EXPECT_EQ("google.com",
             ServerBoundCertService::GetDomainForHost("www.mail.google.com"));
-  EXPECT_EQ("goto",
-            ServerBoundCertService::GetDomainForHost("goto"));
-  EXPECT_EQ("127.0.0.1",
-            ServerBoundCertService::GetDomainForHost("127.0.0.1"));
+  EXPECT_EQ("goto", ServerBoundCertService::GetDomainForHost("goto"));
+  EXPECT_EQ("127.0.0.1", ServerBoundCertService::GetDomainForHost("127.0.0.1"));
 }
 
 TEST_F(ServerBoundCertServiceTest, GetCacheMiss) {
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ServerBoundCertService::RequestHandle request_handle;
 
   // Synchronous completion, because the store is initialized.
@@ skipping 10 matching lines @@
 TEST_F(ServerBoundCertServiceTest, CacheHit) {
   std::string host("encrypted.google.com");
 
   int error;
   TestCompletionCallback callback;
   ServerBoundCertService::RequestHandle request_handle;
 
   // Asynchronous completion.
   std::string private_key_info1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info1, &der_cert1,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert(host,
+                                               &private_key_info1,
+                                               &der_cert1,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(1, service_->cert_count());
   EXPECT_FALSE(private_key_info1.empty());
   EXPECT_FALSE(der_cert1.empty());
   EXPECT_FALSE(request_handle.is_active());
 
   // Synchronous completion.
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info2, &der_cert2,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert(host,
+                                               &private_key_info2,
+                                               &der_cert2,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_FALSE(request_handle.is_active());
   EXPECT_EQ(OK, error);
   EXPECT_EQ(1, service_->cert_count());
   EXPECT_EQ(private_key_info1, private_key_info2);
   EXPECT_EQ(der_cert1, der_cert2);
 
   // Synchronous get.
   std::string private_key_info3, der_cert3;
-  error = service_->GetDomainBoundCert(
-      host, &private_key_info3, &der_cert3, callback.callback(),
-      &request_handle);
+  error = service_->GetDomainBoundCert(host,
+                                       &private_key_info3,
+                                       &der_cert3,
+                                       callback.callback(),
+                                       &request_handle);
   EXPECT_FALSE(request_handle.is_active());
   EXPECT_EQ(OK, error);
   EXPECT_EQ(1, service_->cert_count());
   EXPECT_EQ(der_cert1, der_cert3);
   EXPECT_EQ(private_key_info1, private_key_info3);
 
   EXPECT_EQ(3u, service_->requests());
   EXPECT_EQ(2u, service_->cert_store_hits());
   EXPECT_EQ(0u, service_->inflight_joins());
 }
 
 TEST_F(ServerBoundCertServiceTest, StoreCerts) {
   int error;
   TestCompletionCallback callback;
   ServerBoundCertService::RequestHandle request_handle;
 
   std::string host1("encrypted.google.com");
   std::string private_key_info1, der_cert1;
   EXPECT_EQ(0, service_->cert_count());
-  error = service_->GetOrCreateDomainBoundCert(
-      host1, &private_key_info1, &der_cert1,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert(host1,
+                                               &private_key_info1,
+                                               &der_cert1,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(1, service_->cert_count());
 
   std::string host2("www.verisign.com");
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
-      host2, &private_key_info2, &der_cert2,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert(host2,
+                                               &private_key_info2,
+                                               &der_cert2,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(2, service_->cert_count());
 
   std::string host3("www.twitter.com");
   std::string private_key_info3, der_cert3;
-  error = service_->GetOrCreateDomainBoundCert(
-      host3, &private_key_info3, &der_cert3,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert(host3,
+                                               &private_key_info3,
+                                               &der_cert3,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(3, service_->cert_count());
 
   EXPECT_NE(private_key_info1, private_key_info2);
   EXPECT_NE(der_cert1, der_cert2);
   EXPECT_NE(private_key_info1, private_key_info3);
   EXPECT_NE(der_cert1, der_cert3);
   EXPECT_NE(private_key_info2, private_key_info3);
   EXPECT_NE(der_cert2, der_cert3);
 }
 
 // Tests an inflight join.
 TEST_F(ServerBoundCertServiceTest, InflightJoin) {
   std::string host("encrypted.google.com");
   int error;
 
   std::string private_key_info1, der_cert1;
   TestCompletionCallback callback1;
   ServerBoundCertService::RequestHandle request_handle1;
 
   std::string private_key_info2, der_cert2;
   TestCompletionCallback callback2;
   ServerBoundCertService::RequestHandle request_handle2;
 
-  error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info1, &der_cert1,
-      callback1.callback(), &request_handle1);
+  error = service_->GetOrCreateDomainBoundCert(host,
+                                               &private_key_info1,
+                                               &der_cert1,
+                                               callback1.callback(),
+                                               &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
   // Should join with the original request.
-  error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info2, &der_cert2,
-      callback2.callback(), &request_handle2);
+  error = service_->GetOrCreateDomainBoundCert(host,
+                                               &private_key_info2,
+                                               &der_cert2,
+                                               callback2.callback(),
+                                               &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle2.is_active());
 
   error = callback1.WaitForResult();
   EXPECT_EQ(OK, error);
   error = callback2.WaitForResult();
   EXPECT_EQ(OK, error);
 
   EXPECT_EQ(2u, service_->requests());
   EXPECT_EQ(0u, service_->cert_store_hits());
   EXPECT_EQ(1u, service_->inflight_joins());
   EXPECT_EQ(1u, service_->workers_created());
 }
 
 // Tests an inflight join of a Get request to a GetOrCreate request.
 TEST_F(ServerBoundCertServiceTest, InflightJoinGetOrCreateAndGet) {
   std::string host("encrypted.google.com");
   int error;
 
   std::string private_key_info1, der_cert1;
   TestCompletionCallback callback1;
   ServerBoundCertService::RequestHandle request_handle1;
 
   std::string private_key_info2;
   std::string der_cert2;
   TestCompletionCallback callback2;
   ServerBoundCertService::RequestHandle request_handle2;
 
-  error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info1, &der_cert1,
-      callback1.callback(), &request_handle1);
+  error = service_->GetOrCreateDomainBoundCert(host,
+                                               &private_key_info1,
+                                               &der_cert1,
+                                               callback1.callback(),
+                                               &request_handle1);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle1.is_active());
   // Should join with the original request.
-  error = service_->GetDomainBoundCert(
-      host, &private_key_info2, &der_cert2, callback2.callback(),
-      &request_handle2);
+  error = service_->GetDomainBoundCert(host,
+                                       &private_key_info2,
+                                       &der_cert2,
+                                       callback2.callback(),
+                                       &request_handle2);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle2.is_active());
 
   error = callback1.WaitForResult();
   EXPECT_EQ(OK, error);
   error = callback2.WaitForResult();
   EXPECT_EQ(OK, error);
   EXPECT_EQ(der_cert1, der_cert2);
 
   EXPECT_EQ(2u, service_->requests());
   EXPECT_EQ(0u, service_->cert_store_hits());
   EXPECT_EQ(1u, service_->inflight_joins());
   EXPECT_EQ(1u, service_->workers_created());
 }
 
 TEST_F(ServerBoundCertServiceTest, ExtractValuesFromBytesEC) {
   std::string host("encrypted.google.com");
   std::string private_key_info, der_cert;
   int error;
   TestCompletionCallback callback;
   ServerBoundCertService::RequestHandle request_handle;
 
   error = service_->GetOrCreateDomainBoundCert(
-      host, &private_key_info, &der_cert, callback.callback(),
-      &request_handle);
+      host, &private_key_info, &der_cert, callback.callback(), &request_handle);
   EXPECT_EQ(ERR_IO_PENDING, error);
   EXPECT_TRUE(request_handle.is_active());
   error = callback.WaitForResult();
   EXPECT_EQ(OK, error);
 
   base::StringPiece spki_piece;
   ASSERT_TRUE(asn1::ExtractSPKIFromDERCert(der_cert, &spki_piece));
-  std::vector<uint8> spki(
-      spki_piece.data(),
-      spki_piece.data() + spki_piece.size());
+  std::vector<uint8> spki(spki_piece.data(),
+                          spki_piece.data() + spki_piece.size());
 
   // Check that we can retrieve the key from the bytes.
   std::vector<uint8> key_vec(private_key_info.begin(), private_key_info.end());
   scoped_ptr<crypto::ECPrivateKey> private_key(
       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
           ServerBoundCertService::kEPKIPassword, key_vec, spki));
   EXPECT_TRUE(private_key != NULL);
 
   // Check that we can retrieve the cert from the bytes.
   scoped_refptr<X509Certificate> x509cert(
@@ skipping 169 matching lines @@
 
   EXPECT_NE(private_key_info2, private_key_info3);
   EXPECT_NE(der_cert2, der_cert3);
 
   EXPECT_EQ(3, service_->cert_count());
 }
 
 TEST_F(ServerBoundCertServiceTest, Expiration) {
   ServerBoundCertStore* store = service_->GetCertStore();
   base::Time now = base::Time::Now();
-  store->SetServerBoundCert("good",
-                            now,
-                            now + base::TimeDelta::FromDays(1),
-                            "a",
-                            "b");
+  store->SetServerBoundCert(
+      "good", now, now + base::TimeDelta::FromDays(1), "a", "b");
   store->SetServerBoundCert("expired",
                             now - base::TimeDelta::FromDays(2),
                             now - base::TimeDelta::FromDays(1),
                             "c",
                             "d");
   EXPECT_EQ(2, service_->cert_count());
 
   int error;
   TestCompletionCallback callback;
   ServerBoundCertService::RequestHandle request_handle;
 
   // Cert is valid - synchronous completion.
   std::string private_key_info1, der_cert1;
-  error = service_->GetOrCreateDomainBoundCert(
-      "good", &private_key_info1, &der_cert1,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert("good",
+                                               &private_key_info1,
+                                               &der_cert1,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(OK, error);
   EXPECT_FALSE(request_handle.is_active());
   EXPECT_EQ(2, service_->cert_count());
   EXPECT_STREQ("a", private_key_info1.c_str());
   EXPECT_STREQ("b", der_cert1.c_str());
 
   // Expired cert is valid as well - synchronous completion.
   std::string private_key_info2, der_cert2;
-  error = service_->GetOrCreateDomainBoundCert(
-      "expired", &private_key_info2, &der_cert2,
-      callback.callback(), &request_handle);
+  error = service_->GetOrCreateDomainBoundCert("expired",
+                                               &private_key_info2,
+                                               &der_cert2,
+                                               callback.callback(),
+                                               &request_handle);
   EXPECT_EQ(OK, error);
   EXPECT_FALSE(request_handle.is_active());
   EXPECT_EQ(2, service_->cert_count());
   EXPECT_STREQ("c", private_key_info2.c_str());
   EXPECT_STREQ("d", der_cert2.c_str());
 }
 
 TEST_F(ServerBoundCertServiceTest, AsyncStoreGetOrCreateNoCertsInStore) {
   MockServerBoundCertStoreWithAsyncGet* mock_store =
       new MockServerBoundCertStoreWithAsyncGet();
@@ skipping 176 matching lines @@
   EXPECT_EQ(der_cert1, der_cert2);
   EXPECT_FALSE(private_key1.empty());
   EXPECT_EQ(private_key1, private_key2);
   EXPECT_FALSE(request_handle1.is_active());
   EXPECT_FALSE(request_handle2.is_active());
 }
 
 }  // namespace
 
 }  // namespace net