git cl format the second third of the net/base directory

net/base/keygen_handler_unittest.cc

 // Copyright (c) 2011 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/base/keygen_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "crypto/nss_crypto_module_delegate.h"
 #include "crypto/scoped_test_nss_db.h"
 #endif
 
 namespace net {
 
 namespace {
 
 #if defined(USE_NSS)
 class StubCryptoModuleDelegate : public crypto::NSSCryptoModuleDelegate {
-  public:
-   explicit StubCryptoModuleDelegate(crypto::ScopedPK11Slot slot)
-       : slot_(slot.Pass()) {}
+ public:
+  explicit StubCryptoModuleDelegate(crypto::ScopedPK11Slot slot)
+      : slot_(slot.Pass()) {}
 
-   virtual std::string RequestPassword(const std::string& slot_name,
-                                       bool retry,
-                                       bool* cancelled) override{
-     return std::string();
-   }
+  virtual std::string RequestPassword(const std::string& slot_name,
+                                      bool retry,
+                                      bool* cancelled) override {
+    return std::string();
+  }
 
-   virtual crypto::ScopedPK11Slot RequestSlot() override {
-     return crypto::ScopedPK11Slot(PK11_ReferenceSlot(slot_.get()));
-   }
+  virtual crypto::ScopedPK11Slot RequestSlot() override {
+    return crypto::ScopedPK11Slot(PK11_ReferenceSlot(slot_.get()));
+  }
 
-  private:
-   crypto::ScopedPK11Slot slot_;
+ private:
+  crypto::ScopedPK11Slot slot_;
 };
 #endif
 
 class KeygenHandlerTest : public ::testing::Test {
  public:
   KeygenHandlerTest() {}
   virtual ~KeygenHandlerTest() {}
 
   scoped_ptr<KeygenHandler> CreateKeygenHandler() {
     scoped_ptr<KeygenHandler> handler(new KeygenHandler(
@@ skipping 76 matching lines @@
   // segfaults on shutdown when the threads' thread-specific data
   // destructors run.
   PR_DetachThread();
 #endif
 }
 
 // We asynchronously generate the keys so as not to hang up the IO thread. This
 // test tries to catch concurrency problems in the keygen implementation.
 TEST_F(KeygenHandlerTest, ConcurrencyTest) {
   const int NUM_HANDLERS = 5;
-  base::WaitableEvent* events[NUM_HANDLERS] = { NULL };
+  base::WaitableEvent* events[NUM_HANDLERS] = {NULL};
   std::string results[NUM_HANDLERS];
   for (int i = 0; i < NUM_HANDLERS; i++) {
     scoped_ptr<KeygenHandler> handler(CreateKeygenHandler());
     events[i] = new base::WaitableEvent(false, false);
     base::WorkerPool::PostTask(FROM_HERE,
                                base::Bind(ConcurrencyTestCallback,
                                           "some challenge",
                                           events[i],
                                           base::Passed(&handler),
                                           &results[i]),
                                true);
   }
 
   for (int i = 0; i < NUM_HANDLERS; i++) {
     // Make sure the job completed
     events[i]->Wait();
     delete events[i];
     events[i] = NULL;
 
     VLOG(1) << "KeygenHandler " << i << " produced: " << results[i];
     AssertValidSignedPublicKeyAndChallenge(results[i], "some challenge");
   }
 }
 
 }  // namespace
 
 }  // namespace net