Readability review

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_
 #pragma once
 
 #include <list>
 #include <vector>
@@ skipping 16 matching lines @@
 // 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>
 class PriorityQueue : public base::NonThreadSafe {
  private:
   // This section is up-front for Pointer only.
 #if !defined(NDEBUG)
-  typedef std::list<std::pair<size_t, T> > List;
+  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<size_t>(-1);
+      id_ = static_cast<unsigned>(-1);
 #endif
     }
 
+    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)
+      id_ = p.id_;
+#endif
+      return *this;
+    }
+
     bool is_null() const { return priority_ == kNullPriority; }
 
     Priority priority() const { return priority_; }
 
 #if !defined(NDEBUG)
     const T& value() const { return iterator_->second; }
 #else
     const T& value() const { return *iterator_; }
 #endif
 
@@ skipping 21 matching lines @@
 #if !defined(NDEBUG)
       id_ = iterator_->first;
 #endif
     }
 
     Priority priority_;
     ListIterator iterator_;
 
 #if !defined(NDEBUG)
     // Used by the queue to check if a Pointer is valid.
-    size_t id_;
+    unsigned id_;
 #endif
   };
 
   // Creates a new queue for |num_priorities|.
   explicit PriorityQueue(Priority num_priorities)
       : lists_(num_priorities), size_(0) {
 #if !defined(NDEBUG)
     next_id_ = 0;
 #endif
   }
 
   // Adds |value| with |priority| to the queue. Returns a pointer to the
   // created element.
   Pointer Insert(const T& value, Priority priority) {
     DCHECK(CalledOnValidThread());
     DCHECK_LT(priority, lists_.size());
     ++size_;
     List& list = lists_[priority];
 #if !defined(NDEBUG)
-    size_t id = next_id_;
+    unsigned id = next_id_;
     valid_ids_.insert(id);
     ++next_id_;
     return Pointer(priority, list.insert(list.end(),
                                          std::make_pair(id, value)));
 #else
     return Pointer(priority, list.insert(list.end(), value));
 #endif
   }
 
   // Removes the value pointed by |pointer| from the queue. All pointers to this
@@ skipping 73 matching lines @@
   // Returns number of queued values.
   size_t size() const {
     DCHECK(CalledOnValidThread());
     return size_;
   }
 
  private:
   typedef std::vector<List> ListVector;
 
 #if !defined(NDEBUG)
-  size_t next_id_;
-  base::hash_set<size_t> valid_ids_;
+  unsigned next_id_;
+  base::hash_set<unsigned> valid_ids_;
 #endif
 
   ListVector lists_;
   size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(PriorityQueue);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_PRIORITY_QUEUE_H_
-