Deprecate NonThreadSafe in net/ in favor of SequenceChecker/ThreadChecker.

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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/sequence_checker.h"
 
 #if !defined(NDEBUG)
 #include <unordered_set>
 #endif
 
 namespace net {
 
 // 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>
-class PriorityQueue : public base::NonThreadSafe {
+template <typename T>
+class PriorityQueue {
  private:
   // 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_t Priority;
@@ skipping 85 matching lines @@
   };
 
   // Creates a new queue for |num_priorities|.
   explicit PriorityQueue(Priority num_priorities)
       : lists_(num_priorities), size_(0) {
 #if !defined(NDEBUG)
     next_id_ = 0;
 #endif
   }
 
+  ~PriorityQueue() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }
+
   // Adds |value| with |priority| to the queue. Returns a pointer to the
   // created element.
   Pointer Insert(const T& value, Priority priority) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     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)));
 #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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     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)));
 #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_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     DCHECK_LT(pointer.priority_, lists_.size());
     DCHECK_GT(size_, 0u);
 
 #if !defined(NDEBUG)
     DCHECK_EQ(1u, valid_ids_.erase(pointer.id_));
     DCHECK_EQ(pointer.iterator_->first, pointer.id_);
 #endif
 
     --size_;
     lists_[pointer.priority_].erase(pointer.iterator_);
   }
 
   // Returns a pointer to the first value of minimum priority or a null-pointer
   // if empty.
   Pointer FirstMin() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     for (size_t i = 0; i < lists_.size(); ++i) {
       List* list = const_cast<List*>(&lists_[i]);
       if (!list->empty())
         return Pointer(i, list->begin());
     }
     return Pointer();
   }
 
   // Returns a pointer to the last value of minimum priority or a null-pointer
   // if empty.
   Pointer LastMin() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     for (size_t i = 0; i < lists_.size(); ++i) {
       List* list = const_cast<List*>(&lists_[i]);
       if (!list->empty())
         return Pointer(i, --list->end());
     }
     return Pointer();
   }
 
   // Returns a pointer to the first value of maximum priority or a null-pointer
   // if empty.
   Pointer FirstMax() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     for (size_t i = lists_.size(); i > 0; --i) {
       size_t index = i - 1;
       List* list = const_cast<List*>(&lists_[index]);
       if (!list->empty())
         return Pointer(index, list->begin());
     }
     return Pointer();
   }
 
   // Returns a pointer to the last value of maximum priority or a null-pointer
   // if empty.
   Pointer LastMax() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     for (size_t i = lists_.size(); i > 0; --i) {
       size_t index = i - 1;
       List* list = const_cast<List*>(&lists_[index]);
       if (!list->empty())
         return Pointer(index, --list->end());
     }
     return Pointer();
   }
 
   // Given an ordering of the values in this queue by decreasing
   // priority and then FIFO, returns a pointer to the value following
   // the value of the given pointer (which must be non-NULL).
   //
   // (One could also implement GetNextTowardsFirstMin() [decreasing
   // priority, then reverse FIFO] as well as
   // GetNextTowards{First,Last}Max() [increasing priority, then
   // {,reverse} FIFO].)
   Pointer GetNextTowardsLastMin(const Pointer& pointer) const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     DCHECK(!pointer.is_null());
     DCHECK_LT(pointer.priority_, lists_.size());
 
     typename Pointer::ListIterator it = pointer.iterator_;
     Priority priority = pointer.priority_;
     DCHECK(it != lists_[priority].end());
     ++it;
     while (it == lists_[priority].end()) {
       if (priority == 0u)
         return Pointer();
       --priority;
       it = const_cast<List*>(&lists_[priority])->begin();
     }
     return Pointer(priority, it);
   }
 
   // Empties the queue. All pointers become invalid.
   void Clear() {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     for (size_t i = 0; i < lists_.size(); ++i) {
       lists_[i].clear();
     }
 #if !defined(NDEBUG)
     valid_ids_.clear();
 #endif
     size_ = 0u;
   }
 
   // Returns the number of priorities the queue supports.
   size_t num_priorities() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return lists_.size();
   }
 
   bool empty() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return size_ == 0;
   }
 
   // Returns number of queued values.
   size_t size() const {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return size_;
   }
 
  private:
   typedef std::vector<List> ListVector;
 
 #if !defined(NDEBUG)
   unsigned next_id_;
   std::unordered_set<unsigned> valid_ids_;
 #endif
 
   ListVector lists_;
   size_t size_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(PriorityQueue);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_PRIORITY_QUEUE_H_