Clang format slam.

net/base/priority_queue.h

 // 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.
 
 #ifndef NET_BASE_PRIORITY_QUEUE_H_
 #define NET_BASE_PRIORITY_QUEUE_H_
 
 #include <list>
 #include <vector>
 
@@ skipping 10 matching lines @@
 
 // A simple priority queue. The order of values is by priority and then FIFO.
 // Unlike the std::priority_queue, this implementation allows erasing elements
 // from the queue, and all operations are O(p) time for p priority levels.
 // The queue is agnostic to priority ordering (whether 0 precedes 1).
 // If the highest priority is 0, FirstMin() returns the first in order.
 //
 // In debug-mode, the internal queues store (id, value) pairs where id is used
 // to validate Pointers.
 //
-template<typename T>
+template <typename T>
 class PriorityQueue : public base::NonThreadSafe {
  private:
-  // This section is up-front for Pointer only.
+// This section is up-front for Pointer only.
 #if !defined(NDEBUG)
   typedef std::list<std::pair<unsigned, T> > List;
 #else
   typedef std::list<T> List;
 #endif
 
  public:
   typedef uint32 Priority;
 
   // A pointer to a value stored in the queue. The pointer becomes invalid
   // when the queue is destroyed or cleared, or the value is erased.
   class Pointer {
    public:
     // Constructs a null pointer.
     Pointer() : priority_(kNullPriority) {
 #if !defined(NDEBUG)
       id_ = static_cast<unsigned>(-1);
 #endif
       // TODO(syzm)
       // An uninitialized iterator behaves like an uninitialized pointer as per
       // the STL docs. The fix below is ugly and should possibly be replaced
       // with a better approach.
       iterator_ = dummy_empty_list_.end();
     }
 
-    Pointer(const Pointer& p)
-        : priority_(p.priority_),
-          iterator_(p.iterator_) {
+    Pointer(const Pointer& p) : priority_(p.priority_), iterator_(p.iterator_) {
 #if !defined(NDEBUG)
       id_ = p.id_;
 #endif
     }
 
     Pointer& operator=(const Pointer& p) {
       // Self-assignment is benign.
       priority_ = p.priority_;
       iterator_ = p.iterator_;
 #if !defined(NDEBUG)
@@ skipping 10 matching lines @@
     const T& value() const { return iterator_->second; }
 #else
     const T& value() const { return *iterator_; }
 #endif
 
     // Comparing to Pointer from a different PriorityQueue is undefined.
     bool Equals(const Pointer& other) const {
       return (priority_ == other.priority_) && (iterator_ == other.iterator_);
     }
 
-    void Reset() {
-      *this = Pointer();
-    }
+    void Reset() { *this = Pointer(); }
 
    private:
     friend class PriorityQueue;
 
     // Note that we need iterator and not const_iterator to pass to
     // List::erase.  When C++11 is turned on for Chromium, this could
     // be changed to const_iterator and the const_casts in the rest of
     // the file can be removed.
     typedef typename PriorityQueue::List::iterator ListIterator;
 
@@ skipping 33 matching lines @@
   // created element.
   Pointer Insert(const T& value, Priority priority) {
     DCHECK(CalledOnValidThread());
     DCHECK_LT(priority, lists_.size());
     ++size_;
     List& list = lists_[priority];
 #if !defined(NDEBUG)
     unsigned id = next_id_;
     valid_ids_.insert(id);
     ++next_id_;
-    return Pointer(priority, list.insert(list.end(),
-                                         std::make_pair(id, value)));
+    return Pointer(priority,
+                   list.insert(list.end(), std::make_pair(id, value)));
 #else
     return Pointer(priority, list.insert(list.end(), value));
 #endif
   }
 
   // Adds |value| with |priority| to the queue. Returns a pointer to the
   // created element.
   Pointer InsertAtFront(const T& value, Priority priority) {
     DCHECK(CalledOnValidThread());
     DCHECK_LT(priority, lists_.size());
     ++size_;
     List& list = lists_[priority];
 #if !defined(NDEBUG)
     unsigned id = next_id_;
     valid_ids_.insert(id);
     ++next_id_;
-    return Pointer(priority, list.insert(list.begin(),
-                                         std::make_pair(id, value)));
+    return Pointer(priority,
+                   list.insert(list.begin(), std::make_pair(id, value)));
 #else
     return Pointer(priority, list.insert(list.begin(), value));
 #endif
   }
 
   // Removes the value pointed by |pointer| from the queue. All pointers to this
   // value including |pointer| become invalid.
   void Erase(const Pointer& pointer) {
     DCHECK(CalledOnValidThread());
     DCHECK_LT(pointer.priority_, lists_.size());
@@ skipping 123 matching lines @@
 
   ListVector lists_;
   size_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(PriorityQueue);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_PRIORITY_QUEUE_H_