Create WebSocketTransportClientSocketPool

base/containers/linked_list.h

 // Copyright (c) 2009 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 BASE_CONTAINERS_LINKED_LIST_H_
 #define BASE_CONTAINERS_LINKED_LIST_H_
 
+#include "base/macros.h"
+
 // Simple LinkedList type. (See the Q&A section to understand how this
 // differs from std::list).
 //
 // To use, start by declaring the class which will be contained in the linked
 // list, as extending LinkNode (this gives it next/previous pointers).
 //
 //   class MyNodeType : public LinkNode<MyNodeType> {
 //     ...
 //   };
 //
@@ skipping 57 matching lines @@
 //    space for the "next" and "previous" pointers (base::LinkNode<T>*).
 //    Whereas with std::list<T> the type can be anything, so the implementation
 //    needs to glue on the "next" and "previous" pointers using
 //    some internal node type.
 
 namespace base {
 
 template <typename T>
 class LinkNode {
  public:
-  LinkNode() : previous_(0), next_(0) {}
+  LinkNode() : previous_(NULL), next_(NULL) {}
   LinkNode(LinkNode<T>* previous, LinkNode<T>* next)
       : previous_(previous), next_(next) {}
 
   // Insert |this| into the linked list, before |e|.
   void InsertBefore(LinkNode<T>* e) {
     this->next_ = e;
     this->previous_ = e->previous_;
     e->previous_->next_ = this;
     e->previous_ = this;
   }
 
   // Insert |this| into the linked list, after |e|.
   void InsertAfter(LinkNode<T>* e) {
     this->next_ = e->next_;
     this->previous_ = e;
     e->next_->previous_ = this;
     e->next_ = this;
   }
 
   // Remove |this| from the linked list.
   void RemoveFromList() {
     this->previous_->next_ = this->next_;
     this->next_->previous_ = this->previous_;
+    // next() and previous() return non-NULL if and only this node is not in any
+    // list.
+    this->next_ = NULL;
+    this->previous_ = NULL;
   }
 
   LinkNode<T>* previous() const {
     return previous_;
   }
 
   LinkNode<T>* next() const {
     return next_;
   }
 
   // Cast from the node-type to the value type.
   const T* value() const {
     return static_cast<const T*>(this);
   }
 
   T* value() {
     return static_cast<T*>(this);
   }
 
  private:
   LinkNode<T>* previous_;
   LinkNode<T>* next_;
+
+  DISALLOW_COPY_AND_ASSIGN(LinkNode);
 };
 
 template <typename T>
 class LinkedList {
  public:
   // The "root" node is self-referential, and forms the basis of a circular
   // list (root_.next() will point back to the start of the list,
   // and root_->previous() wraps around to the end of the list).
   LinkedList() : root_(&root_, &root_) {}
 
   // Appends |e| to the end of the linked list.
   void Append(LinkNode<T>* e) {
     e->InsertBefore(&root_);
   }
 
   LinkNode<T>* head() const {
     return root_.next();
   }
 
   LinkNode<T>* tail() const {
     return root_.previous();
   }
 
   const LinkNode<T>* end() const {
     return &root_;
   }
 
+  bool empty() const { return head() == end(); }
+
  private:
   LinkNode<T> root_;
+
+  DISALLOW_COPY_AND_ASSIGN(LinkedList);
 };
 
 }  // namespace base
 
 #endif  // BASE_CONTAINERS_LINKED_LIST_H_