Clang format slam.

net/base/prioritized_dispatcher_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 <ctype.h>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/prioritized_dispatcher.h"
 #include "net/base/request_priority.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 // We rely on the priority enum values being sequential having starting at 0,
 // and increasing for higher priorities.
 COMPILE_ASSERT(MINIMUM_PRIORITY == 0u &&
-               MINIMUM_PRIORITY == IDLE &&
-               IDLE < LOWEST &&
-               LOWEST < HIGHEST &&
-               HIGHEST <= MAXIMUM_PRIORITY,
+                   MINIMUM_PRIORITY ==
+                       IDLE&& IDLE < LOWEST&& LOWEST < HIGHEST&& HIGHEST <=
+                           MAXIMUM_PRIORITY,
                priority_indexes_incompatible);
 
 class PrioritizedDispatcherTest : public testing::Test {
  public:
   typedef PrioritizedDispatcher::Priority Priority;
   // A job that appends |tag| to |log| when started and '.' when finished.
   // This is intended to confirm the execution order of a sequence of jobs added
   // to the dispatcher. Note that finishing order of jobs does not matter.
   class TestJob : public PrioritizedDispatcher::Job {
    public:
     TestJob(PrioritizedDispatcher* dispatcher,
             char tag,
             Priority priority,
             std::string* log)
         : dispatcher_(dispatcher),
           tag_(tag),
           priority_(priority),
           running_(false),
           log_(log) {}
 
-    bool running() const {
-      return running_;
-    }
+    bool running() const { return running_; }
 
-    const PrioritizedDispatcher::Handle handle() const {
-      return handle_;
-    }
+    const PrioritizedDispatcher::Handle handle() const { return handle_; }
 
     void Add(bool at_head) {
       CHECK(handle_.is_null());
       CHECK(!running_);
       size_t num_queued = dispatcher_->num_queued_jobs();
       size_t num_running = dispatcher_->num_running_jobs();
 
       if (!at_head) {
         handle_ = dispatcher_->Add(this, priority_);
       } else {
@@ skipping 211 matching lines @@
 }
 
 TEST_F(PrioritizedDispatcherTest, EnforceLimits) {
   // Reserve 2 for HIGHEST and 1 for LOW or higher.
   // This leaves 2 for LOWEST or lower.
   PrioritizedDispatcher::Limits limits(NUM_PRIORITIES, 5);
   limits.reserved_slots[HIGHEST] = 2;
   limits.reserved_slots[LOW] = 1;
   Prepare(limits);
 
-  TestJob* job_a = AddJob('a', IDLE);    // Uses unreserved slot.
-  TestJob* job_b = AddJob('b', IDLE);    // Uses unreserved slot.
-  TestJob* job_c = AddJob('c', LOWEST);  // Must wait.
-  TestJob* job_d = AddJob('d', LOW);     // Uses reserved slot.
-  TestJob* job_e = AddJob('e', MEDIUM);  // Must wait.
-  TestJob* job_f = AddJob('f', HIGHEST); // Uses reserved slot.
-  TestJob* job_g = AddJob('g', HIGHEST); // Uses reserved slot.
-  TestJob* job_h = AddJob('h', HIGHEST); // Must wait.
+  TestJob* job_a = AddJob('a', IDLE);     // Uses unreserved slot.
+  TestJob* job_b = AddJob('b', IDLE);     // Uses unreserved slot.
+  TestJob* job_c = AddJob('c', LOWEST);   // Must wait.
+  TestJob* job_d = AddJob('d', LOW);      // Uses reserved slot.
+  TestJob* job_e = AddJob('e', MEDIUM);   // Must wait.
+  TestJob* job_f = AddJob('f', HIGHEST);  // Uses reserved slot.
+  TestJob* job_g = AddJob('g', HIGHEST);  // Uses reserved slot.
+  TestJob* job_h = AddJob('h', HIGHEST);  // Must wait.
 
   EXPECT_EQ(5u, dispatcher_->num_running_jobs());
   EXPECT_EQ(3u, dispatcher_->num_queued_jobs());
 
   ASSERT_TRUE(job_a->running());
   ASSERT_TRUE(job_b->running());
   ASSERT_TRUE(job_d->running());
   ASSERT_TRUE(job_f->running());
   ASSERT_TRUE(job_g->running());
   // a, b, d, f, g are running. Finish them in any order.
@@ skipping 257 matching lines @@
   Prepare(limits);
   AddJob('a', IDLE);
   AddJob('b', IDLE);
   EXPECT_DEBUG_DEATH(dispatcher_->Cancel(handle), "");
 }
 #endif  // GTEST_HAS_DEATH_TEST && !defined(NDEBUG)
 
 }  // namespace
 
 }  // namespace net