Clang format slam.

net/dns/serial_worker_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/dns/serial_worker.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 class SerialWorkerTest : public testing::Test {
  public:
   // The class under test
   class TestSerialWorker : public SerialWorker {
    public:
-    explicit TestSerialWorker(SerialWorkerTest* t)
-      : test_(t) {}
+    explicit TestSerialWorker(SerialWorkerTest* t) : test_(t) {}
     virtual void DoWork() OVERRIDE {
       ASSERT_TRUE(test_);
       test_->OnWork();
     }
     virtual void OnWorkFinished() OVERRIDE {
       ASSERT_TRUE(test_);
       test_->OnWorkFinished();
     }
+
    private:
     virtual ~TestSerialWorker() {}
     SerialWorkerTest* test_;
   };
 
   // Mocks
 
   void OnWork() {
-    { // Check that OnWork is executed serially.
+    {  // Check that OnWork is executed serially.
       base::AutoLock lock(work_lock_);
       EXPECT_FALSE(work_running_) << "DoRead is not called serially!";
       work_running_ = true;
     }
     BreakNow("OnWork");
     work_allowed_.Wait();
     // Calling from WorkerPool, but protected by work_allowed_/work_called_.
     output_value_ = input_value_;
 
-    { // This lock might be destroyed after work_called_ is signalled.
+    {  // This lock might be destroyed after work_called_ is signalled.
       base::AutoLock lock(work_lock_);
       work_running_ = false;
     }
     work_called_.Signal();
   }
 
   void OnWorkFinished() {
     EXPECT_TRUE(message_loop_ == base::MessageLoop::current());
     EXPECT_EQ(output_value_, input_value_);
     BreakNow("OnWorkFinished");
   }
 
  protected:
   void BreakCallback(std::string breakpoint) {
     breakpoint_ = breakpoint;
     base::MessageLoop::current()->QuitNow();
   }
 
   void BreakNow(std::string b) {
-    message_loop_->PostTask(FROM_HERE,
-        base::Bind(&SerialWorkerTest::BreakCallback,
-                   base::Unretained(this), b));
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &SerialWorkerTest::BreakCallback, base::Unretained(this), b));
   }
 
   void RunUntilBreak(std::string b) {
     message_loop_->Run();
     ASSERT_EQ(breakpoint_, b);
   }
 
   SerialWorkerTest()
       : input_value_(0),
         output_value_(-1),
         work_allowed_(false, false),
         work_called_(false, false),
-        work_running_(false) {
-  }
+        work_running_(false) {}
 
   // Helpers for tests.
 
   // Lets OnWork run and waits for it to complete. Can only return if OnWork is
   // executed on a concurrent thread.
   void WaitForWork() {
     RunUntilBreak("OnWork");
     work_allowed_.Signal();
     work_called_.Wait();
   }
@@ skipping 56 matching lines @@
   WaitForWork();
   RunUntilBreak("OnWorkFinished");
 
   // No more tasks should remain.
   EXPECT_TRUE(message_loop_->IsIdleForTesting());
 }
 
 }  // namespace
 
 }  // namespace net
-