Clang format slam.

net/base/prioritized_dispatcher.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 "net/base/prioritized_dispatcher.h"
 
 #include "base/logging.h"
 
 namespace net {
 
 PrioritizedDispatcher::Limits::Limits(Priority num_priorities,
                                       size_t total_jobs)
-    : total_jobs(total_jobs), reserved_slots(num_priorities) {}
+    : total_jobs(total_jobs), reserved_slots(num_priorities) {
+}
 
-PrioritizedDispatcher::Limits::~Limits() {}
+PrioritizedDispatcher::Limits::~Limits() {
+}
 
 PrioritizedDispatcher::PrioritizedDispatcher(const Limits& limits)
     : queue_(limits.reserved_slots.size()),
       max_running_jobs_(limits.reserved_slots.size()),
       num_running_jobs_(0) {
   SetLimits(limits);
 }
 
-PrioritizedDispatcher::~PrioritizedDispatcher() {}
+PrioritizedDispatcher::~PrioritizedDispatcher() {
+}
 
-PrioritizedDispatcher::Handle PrioritizedDispatcher::Add(
-    Job* job, Priority priority) {
+PrioritizedDispatcher::Handle PrioritizedDispatcher::Add(Job* job,
+                                                         Priority priority) {
   DCHECK(job);
   DCHECK_LT(priority, num_priorities());
   if (num_running_jobs_ < max_running_jobs_[priority]) {
     ++num_running_jobs_;
     job->Start();
     return Handle();
   }
   return queue_.Insert(job, priority);
 }
 
 PrioritizedDispatcher::Handle PrioritizedDispatcher::AddAtHead(
-    Job* job, Priority priority) {
+    Job* job,
+    Priority priority) {
   DCHECK(job);
   DCHECK_LT(priority, num_priorities());
   if (num_running_jobs_ < max_running_jobs_[priority]) {
     ++num_running_jobs_;
     job->Start();
     return Handle();
   }
   return queue_.InsertAtFront(job, priority);
 }
 
 void PrioritizedDispatcher::Cancel(const Handle& handle) {
   queue_.Erase(handle);
 }
 
 PrioritizedDispatcher::Job* PrioritizedDispatcher::EvictOldestLowest() {
   Handle handle = queue_.FirstMin();
   if (handle.is_null())
     return NULL;
   Job* job = handle.value();
   Cancel(handle);
   return job;
 }
 
 PrioritizedDispatcher::Handle PrioritizedDispatcher::ChangePriority(
-    const Handle& handle, Priority priority) {
+    const Handle& handle,
+    Priority priority) {
   DCHECK(!handle.is_null());
   DCHECK_LT(priority, num_priorities());
-  DCHECK_GE(num_running_jobs_, max_running_jobs_[handle.priority()]) <<
-      "Job should not be in queue when limits permit it to start.";
+  DCHECK_GE(num_running_jobs_, max_running_jobs_[handle.priority()])
+      << "Job should not be in queue when limits permit it to start.";
 
   if (handle.priority() == priority)
     return handle;
 
   if (MaybeDispatchJob(handle, priority))
     return Handle();
   Job* job = handle.value();
   queue_.Erase(handle);
   return queue_.Insert(job, priority);
 }
@@ skipping 57 matching lines @@
 bool PrioritizedDispatcher::MaybeDispatchNextJob() {
   Handle handle = queue_.FirstMax();
   if (handle.is_null()) {
     DCHECK_EQ(0u, queue_.size());
     return false;
   }
   return MaybeDispatchJob(handle, handle.priority());
 }
 
 }  // namespace net