Clang format slam.

net/base/net_log_unittest.cc

 // Copyright (c) 2013 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/net_log_unittest.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/simple_thread.h"
@@ skipping 62 matching lines @@
 
 class CountingObserver : public NetLog::ThreadSafeObserver {
  public:
   CountingObserver() : count_(0) {}
 
   virtual ~CountingObserver() {
     if (net_log())
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
-    ++count_;
-  }
+  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE { ++count_; }
 
   int count() const { return count_; }
 
  private:
   int count_;
 };
 
 class LoggingObserver : public NetLog::ThreadSafeObserver {
  public:
   LoggingObserver() {}
@@ skipping 23 matching lines @@
 
 void AddEvent(NetLog* net_log) {
   net_log->AddGlobalEntry(NetLog::TYPE_CANCELLED, base::Bind(LogLevelToValue));
 }
 
 // A thread that waits until an event has been signalled before calling
 // RunTestThread.
 class NetLogTestThread : public base::SimpleThread {
  public:
   NetLogTestThread()
-      : base::SimpleThread("NetLogTest"),
-        net_log_(NULL),
-        start_event_(NULL) {
-  }
+      : base::SimpleThread("NetLogTest"), net_log_(NULL), start_event_(NULL) {}
 
   // We'll wait for |start_event| to be triggered before calling a subclass's
   // subclass's RunTestThread() function.
   void Init(NetLog* net_log, base::WaitableEvent* start_event) {
     start_event_ = start_event;
     net_log_ = net_log;
   }
 
   virtual void Run() OVERRIDE {
     start_event_->Wait();
@@ skipping 28 matching lines @@
   }
 
   DISALLOW_COPY_AND_ASSIGN(AddEventsTestThread);
 };
 
 // A thread that adds and removes an observer from the NetLog repeatedly.
 class AddRemoveObserverTestThread : public NetLogTestThread {
  public:
   AddRemoveObserverTestThread() {}
 
-  virtual ~AddRemoveObserverTestThread() {
-    EXPECT_TRUE(!observer_.net_log());
-  }
+  virtual ~AddRemoveObserverTestThread() { EXPECT_TRUE(!observer_.net_log()); }
 
  private:
   virtual void RunTestThread() OVERRIDE {
     for (int i = 0; i < kEvents; ++i) {
       ASSERT_FALSE(observer_.net_log());
 
       net_log_->AddThreadSafeObserver(&observer_, NetLog::LOG_ALL_BUT_BYTES);
       ASSERT_EQ(net_log_, observer_.net_log());
       ASSERT_EQ(NetLog::LOG_ALL_BUT_BYTES, observer_.log_level());
       ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL_BUT_BYTES);
 
       net_log_->SetObserverLogLevel(&observer_, NetLog::LOG_ALL);
       ASSERT_EQ(net_log_, observer_.net_log());
       ASSERT_EQ(NetLog::LOG_ALL, observer_.log_level());
       ASSERT_LE(net_log_->GetLogLevel(), NetLog::LOG_ALL);
 
       net_log_->RemoveThreadSafeObserver(&observer_);
       ASSERT_TRUE(!observer_.net_log());
     }
   }
 
   CountingObserver observer_;
 
   DISALLOW_COPY_AND_ASSIGN(AddRemoveObserverTestThread);
 };
 
 // Creates |kThreads| threads of type |ThreadType| and then runs them all
 // to completion.
-template<class ThreadType>
+template <class ThreadType>
 void RunTestThreads(NetLog* net_log) {
   ThreadType threads[kThreads];
   base::WaitableEvent start_event(true, false);
 
   for (size_t i = 0; i < arraysize(threads); ++i) {
     threads[i].Init(net_log, &start_event);
     threads[i].Start();
   }
 
   start_event.Signal();
@@ skipping 129 matching lines @@
   NetLog net_log;
 
   // Run a bunch of threads to completion, each of which will repeatedly add
   // and remove an observer, and set its logging level.
   RunTestThreads<AddRemoveObserverTestThread>(&net_log);
 }
 
 }  // namespace
 
 }  // namespace net