Fix trailing whitespace in .cpp, .h, and .idl files (ex. Source/core)

Source/wtf/ListHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 109 matching lines @@
 
         // An alternate version of find() that finds the object by hashing and comparing
         // with some other type, to avoid the cost of type conversion.
         // The HashTranslator interface is defined in HashSet.
         // FIXME: We should reverse the order of the template arguments so that callers
         // can just pass the translator let the compiler deduce T.
         template<typename T, typename HashTranslator> iterator find(const T&);
         template<typename T, typename HashTranslator> const_iterator find(const T&) const;
         template<typename T, typename HashTranslator> bool contains(const T&) const;
 
-        // The return value of add is a pair of an iterator to the new value's location, 
+        // The return value of add is a pair of an iterator to the new value's location,
         // and a bool that is true if an new entry was added.
         AddResult add(const ValueType&);
 
         // Add the value to the end of the collection. If the value was already in
         // the list, it is moved to the end.
         AddResult appendOrMoveToLast(const ValueType&);
 
         // Add the value to the beginning of the collection. If the value was already in
         // the list, it is moved to the beginning.
         AddResult prependOrMoveToFirst(const ValueType&);
 
         AddResult insertBefore(const ValueType& beforeValue, const ValueType& newValue);
         AddResult insertBefore(iterator, const ValueType&);
 
         void remove(const ValueType&);
         void remove(iterator);
         void clear();
 
     private:
         void unlink(Node*);
         void unlinkAndDelete(Node*);
         void appendNode(Node*);
         void prependNode(Node*);
         void insertNodeBefore(Node* beforeNode, Node* newNode);
         void deleteAllNodes();
-        
+
         iterator makeIterator(Node*);
         const_iterator makeConstIterator(Node*) const;
         reverse_iterator makeReverseIterator(Node*);
         const_reverse_iterator makeConstReverseIterator(Node*) const;
 
         friend void deleteAllValues<>(const ListHashSet&);
 
         ImplType m_impl;
         Node* m_head;
         Node* m_tail;
         OwnPtr<NodeAllocator> m_allocator;
     };
 
     template<typename ValueArg, size_t inlineCapacity> struct ListHashSetNodeAllocator {
         typedef ListHashSetNode<ValueArg, inlineCapacity> Node;
         typedef ListHashSetNodeAllocator<ValueArg, inlineCapacity> NodeAllocator;
 
-        ListHashSetNodeAllocator() 
+        ListHashSetNodeAllocator()
             : m_freeList(pool())
             , m_isDoneWithInitialFreeList(false)
-        { 
+        {
             memset(m_pool.pool, 0, sizeof(m_pool.pool));
         }
 
         Node* allocate()
-        { 
+        {
             Node* result = m_freeList;
 
             if (!result)
                 return static_cast<Node*>(fastMalloc(sizeof(Node)));
 
             ASSERT(!result->m_isAllocated);
 
             Node* next = result->m_next;
             ASSERT(!next || !next->m_isAllocated);
             if (!next && !m_isDoneWithInitialFreeList) {
                 next = result + 1;
                 if (next == pastPool()) {
                     m_isDoneWithInitialFreeList = true;
                     next = 0;
                 } else {
                     ASSERT(inPool(next));
                     ASSERT(!next->m_isAllocated);
                 }
             }
             m_freeList = next;
 
             return result;
         }
 
-        void deallocate(Node* node) 
+        void deallocate(Node* node)
         {
             if (inPool(node)) {
 #ifndef NDEBUG
                 node->m_isAllocated = false;
 #endif
                 node->m_next = m_freeList;
                 m_freeList = node;
                 return;
             }
 
@@ skipping 328 matching lines @@
 
     template<typename T, size_t inlineCapacity, typename U>
     inline ListHashSet<T, inlineCapacity, U>::~ListHashSet()
     {
         deleteAllNodes();
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline int ListHashSet<T, inlineCapacity, U>::size() const
     {
-        return m_impl.size(); 
+        return m_impl.size();
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline int ListHashSet<T, inlineCapacity, U>::capacity() const
     {
-        return m_impl.capacity(); 
+        return m_impl.capacity();
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline bool ListHashSet<T, inlineCapacity, U>::isEmpty() const
     {
-        return m_impl.isEmpty(); 
+        return m_impl.isEmpty();
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     size_t ListHashSet<T, inlineCapacity, U>::sizeInBytes() const
     {
         size_t result = sizeof(*this) + sizeof(*m_allocator);
         result += sizeof(typename ImplType::ValueType) * m_impl.capacity();
         for (Node* node = m_head; node; node = node->m_next) {
             if (!m_allocator->inPool(node))
                 result += sizeof(Node);
         }
         return result;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::begin()
     {
-        return makeIterator(m_head); 
+        return makeIterator(m_head);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::end()
     {
         return makeIterator(0);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::const_iterator ListHashSet<T, inlineCapacity, U>::begin() const
     {
-        return makeConstIterator(m_head); 
+        return makeConstIterator(m_head);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::const_iterator ListHashSet<T, inlineCapacity, U>::end() const
     {
-        return makeConstIterator(0); 
+        return makeConstIterator(0);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::reverse_iterator ListHashSet<T, inlineCapacity, U>::rbegin()
     {
-        return makeReverseIterator(m_tail); 
+        return makeReverseIterator(m_tail);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::reverse_iterator ListHashSet<T, inlineCapacity, U>::rend()
     {
         return makeReverseIterator(0);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::const_reverse_iterator ListHashSet<T, inlineCapacity, U>::rbegin() const
     {
-        return makeConstReverseIterator(m_tail); 
+        return makeConstReverseIterator(m_tail);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::const_reverse_iterator ListHashSet<T, inlineCapacity, U>::rend() const
     {
-        return makeConstReverseIterator(0); 
+        return makeConstReverseIterator(0);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline T& ListHashSet<T, inlineCapacity, U>::first()
     {
         ASSERT(!isEmpty());
         return m_head->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
@@ skipping 32 matching lines @@
         m_impl.remove(m_tail);
         unlinkAndDelete(m_tail);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::iterator ListHashSet<T, inlineCapacity, U>::find(const ValueType& value)
     {
         ImplTypeIterator it = m_impl.template find<BaseTranslator>(value);
         if (it == m_impl.end())
             return end();
-        return makeIterator(*it); 
+        return makeIterator(*it);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline typename ListHashSet<T, inlineCapacity, U>::const_iterator ListHashSet<T, inlineCapacity, U>::find(const ValueType& value) const
     {
         ImplTypeConstIterator it = m_impl.template find<BaseTranslator>(value);
         if (it == m_impl.end())
             return end();
         return makeConstIterator(*it);
     }
@@ skipping 73 matching lines @@
     {
         typename ImplType::AddResult result = m_impl.template add<BaseTranslator>(newValue, m_allocator.get());
         if (result.isNewEntry)
             insertNodeBefore(it.node(), *result.iterator);
         return AddResult(makeIterator(*result.iterator), result.isNewEntry);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     typename ListHashSet<T, inlineCapacity, U>::AddResult ListHashSet<T, inlineCapacity, U>::insertBefore(const ValueType& beforeValue, const ValueType& newValue)
     {
-        return insertBefore(find(beforeValue), newValue); 
+        return insertBefore(find(beforeValue), newValue);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline void ListHashSet<T, inlineCapacity, U>::remove(iterator it)
     {
         if (it == end())
             return;
         m_impl.remove(it.node());
         unlinkAndDelete(it.node());
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline void ListHashSet<T, inlineCapacity, U>::remove(const ValueType& value)
     {
         remove(find(value));
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline void ListHashSet<T, inlineCapacity, U>::clear()
     {
         deleteAllNodes();
-        m_impl.clear(); 
+        m_impl.clear();
         m_head = 0;
         m_tail = 0;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void ListHashSet<T, inlineCapacity, U>::unlink(Node* node)
     {
         if (!node->m_prev) {
             ASSERT(node == m_head);
             m_head = node->m_next;
@@ skipping 47 matching lines @@
             m_tail = node;
 
         m_head = node;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void ListHashSet<T, inlineCapacity, U>::insertNodeBefore(Node* beforeNode, Node* newNode)
     {
         if (!beforeNode)
             return appendNode(newNode);
-        
+
         newNode->m_next = beforeNode;
         newNode->m_prev = beforeNode->m_prev;
         if (beforeNode->m_prev)
             beforeNode->m_prev->m_next = newNode;
         beforeNode->m_prev = newNode;
 
         if (!newNode->m_prev)
             m_head = newNode;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void ListHashSet<T, inlineCapacity, U>::deleteAllNodes()
     {
         if (!m_head)
             return;
 
         for (Node* node = m_head, *next = m_head->m_next; node; node = next, next = node ? node->m_next : 0)
             node->destroy(m_allocator.get());
     }
 
     template<typename T, size_t inlineCapacity, typename U>
-    inline ListHashSetReverseIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeReverseIterator(Node* position) 
+    inline ListHashSetReverseIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeReverseIterator(Node* position)
     {
-        return ListHashSetReverseIterator<T, inlineCapacity, U>(this, position); 
+        return ListHashSetReverseIterator<T, inlineCapacity, U>(this, position);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline ListHashSetConstReverseIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeConstReverseIterator(Node* position) const
-    { 
-        return ListHashSetConstReverseIterator<T, inlineCapacity, U>(this, position); 
+    {
+        return ListHashSetConstReverseIterator<T, inlineCapacity, U>(this, position);
     }
-    
+
     template<typename T, size_t inlineCapacity, typename U>
-    inline ListHashSetIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeIterator(Node* position) 
+    inline ListHashSetIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeIterator(Node* position)
     {
-        return ListHashSetIterator<T, inlineCapacity, U>(this, position); 
+        return ListHashSetIterator<T, inlineCapacity, U>(this, position);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline ListHashSetConstIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeConstIterator(Node* position) const
-    { 
-        return ListHashSetConstIterator<T, inlineCapacity, U>(this, position); 
+    {
+        return ListHashSetConstIterator<T, inlineCapacity, U>(this, position);
     }
     template<bool, typename ValueType, typename HashTableType>
     void deleteAllValues(HashTableType& collection)
     {
         typedef typename HashTableType::const_iterator iterator;
         iterator end = collection.end();
         for (iterator it = collection.begin(); it != end; ++it)
             delete (*it)->m_value;
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline void deleteAllValues(const ListHashSet<T, inlineCapacity, U>& collection)
     {
         deleteAllValues<true, typename ListHashSet<T, inlineCapacity, U>::ValueType>(collection.m_impl);
     }
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */