base::Bind: More random cleanups.

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 "build/build_config.h"
 #include "base/base64.h"
+#include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/task.h"
 #include "base/threading/worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/synchronization/waitable_event.h"
+#include "build/build_config.h"
 #include "crypto/nss_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(USE_NSS)
 #include <private/pprthred.h>  // PR_DetachThread
 #endif
 
 namespace net {
 
 namespace {
@@ skipping 47 matching lines @@
 }
 
 TEST_F(KeygenHandlerTest, SmokeTest) {
   KeygenHandler handler(768, "some challenge", GURL("http://www.example.com"));
   handler.set_stores_key(false);  // Don't leave the key-pair behind
   std::string result = handler.GenKeyAndSignChallenge();
   VLOG(1) << "KeygenHandler produced: " << result;
   AssertValidSignedPublicKeyAndChallenge(result, "some challenge");
 }
 
-class ConcurrencyTestTask : public Task {
- public:
-  ConcurrencyTestTask(base::WaitableEvent* event,
-                      const std::string& challenge, std::string* result)
-      : event_(event),
-        challenge_(challenge),
-        result_(result) {
-  }
-
-  virtual void Run() {
-    // We allow Singleton use on the worker thread here since we use a
-    // WaitableEvent to synchronize, so it's safe.
-    base::ThreadRestrictions::ScopedAllowSingleton scoped_allow_singleton;
-    KeygenHandler handler(768, "some challenge",
-                          GURL("http://www.example.com"));
-    handler.set_stores_key(false);  // Don't leave the key-pair behind.
-    *result_ = handler.GenKeyAndSignChallenge();
-    event_->Signal();
+void ConcurrencyTestCallback(base::WaitableEvent* event,
+                             const std::string& challenge,
+                             std::string* result) {
+  // We allow Singleton use on the worker thread here since we use a
+  // WaitableEvent to synchronize, so it's safe.
+  base::ThreadRestrictions::ScopedAllowSingleton scoped_allow_singleton;
+  KeygenHandler handler(768, challenge, GURL("http://www.example.com"));
+  handler.set_stores_key(false);  // Don't leave the key-pair behind.
+  *result = handler.GenKeyAndSignChallenge();
+  event->Signal();
 #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();
+  // 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
-  }
-
- private:
-  base::WaitableEvent* event_;
-  std::string challenge_;
-  std::string* result_;
-};
+}
 
 // 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 };
   std::string results[NUM_HANDLERS];
   for (int i = 0; i < NUM_HANDLERS; i++) {
     events[i] = new base::WaitableEvent(false, false);
     base::WorkerPool::PostTask(
         FROM_HERE,
-        new ConcurrencyTestTask(events[i], "some challenge", &results[i]),
+        base::Bind(ConcurrencyTestCallback, events[i], "some challenge",
+                   &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