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

Source/wtf/RefPtrHashMap.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  *
  * 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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef RefPtrHashMap_h
 #define RefPtrHashMap_h
 
 namespace WTF {
 
     // This specialization is a copy of HashMap for use with RefPtr keys, with overloaded functions
     // to allow for lookup by pointer instead of RefPtr, avoiding ref-count churn.
-    
+
      // FIXME: Find a way to do this with traits that doesn't require a copy of the HashMap template.
-    
+
     template<typename T, typename MappedArg, typename HashArg, typename KeyTraitsArg, typename MappedTraitsArg>
     class HashMap<RefPtr<T>, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> {
         WTF_MAKE_FAST_ALLOCATED;
     private:
         typedef KeyTraitsArg KeyTraits;
         typedef MappedTraitsArg MappedTraits;
         typedef KeyValuePairHashTraits<KeyTraits, MappedTraits> ValueTraits;
 
     public:
         typedef typename KeyTraits::TraitType KeyType;
         typedef T* RawKeyType;
         typedef typename MappedTraits::TraitType MappedType;
         typedef typename ValueTraits::TraitType ValueType;
 
     private:
         typedef typename MappedTraits::PassInType MappedPassInType;
         typedef typename MappedTraits::PassOutType MappedPassOutType;
         typedef typename MappedTraits::PeekType MappedPeekType;
 
         typedef typename ReferenceTypeMaker<MappedPassInType>::ReferenceType MappedPassInReferenceType;
-        
+
         typedef HashArg HashFunctions;
 
         typedef HashTable<KeyType, ValueType, KeyValuePairKeyExtractor<ValueType>,
             HashFunctions, ValueTraits, KeyTraits> HashTableType;
 
         typedef HashMapTranslator<ValueTraits, HashFunctions>
             Translator;
 
     public:
         typedef HashTableIteratorAdapter<HashTableType, ValueType> iterator;
@@ skipping 16 matching lines @@
         iterator find(RawKeyType);
         const_iterator find(const KeyType&) const;
         const_iterator find(RawKeyType) const;
         bool contains(const KeyType&) const;
         bool contains(RawKeyType) const;
         MappedPeekType get(const KeyType&) const;
         MappedPeekType get(RawKeyType) const;
         MappedPeekType inlineGet(RawKeyType) const;
 
         // replaces value but not key if key is already present
-        // return value is a pair of the iterator to the key location, 
+        // return value is a pair of the iterator to the key location,
         // and a boolean that's true if a new value was actually added
         AddResult set(const KeyType&, MappedPassInType);
         AddResult set(RawKeyType, MappedPassInType);
 
         // does nothing if key is already present
-        // return value is a pair of the iterator to the key location, 
+        // return value is a pair of the iterator to the key location,
         // and a boolean that's true if a new value was actually added
         AddResult add(const KeyType&, MappedPassInType);
         AddResult add(RawKeyType, MappedPassInType);
 
         void remove(const KeyType&);
         void remove(RawKeyType);
         void remove(iterator);
         void clear();
 
         MappedPassOutType take(const KeyType&); // efficient combination of get with remove
         MappedPassOutType take(RawKeyType); // efficient combination of get with remove
 
     private:
         AddResult inlineAdd(const KeyType&, MappedPassInReferenceType);
         AddResult inlineAdd(RawKeyType, MappedPassInReferenceType);
 
         HashTableType m_impl;
     };
-    
+
     template<typename T, typename U, typename V, typename W, typename X>
     inline void HashMap<RefPtr<T>, U, V, W, X>::swap(HashMap& other)
     {
-        m_impl.swap(other.m_impl); 
+        m_impl.swap(other.m_impl);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline int HashMap<RefPtr<T>, U, V, W, X>::size() const
     {
-        return m_impl.size(); 
+        return m_impl.size();
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline int HashMap<RefPtr<T>, U, V, W, X>::capacity() const
-    { 
-        return m_impl.capacity(); 
+    {
+        return m_impl.capacity();
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline bool HashMap<RefPtr<T>, U, V, W, X>::isEmpty() const
     {
         return m_impl.isEmpty();
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline typename HashMap<RefPtr<T>, U, V, W, X>::iterator HashMap<RefPtr<T>, U, V, W, X>::begin()
@@ skipping 50 matching lines @@
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline bool HashMap<RefPtr<T>, U, V, W, X>::contains(RawKeyType key) const
     {
         return m_impl.template contains<Translator>(key);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline typename HashMap<RefPtr<T>, U, V, W, X>::AddResult
-    HashMap<RefPtr<T>, U, V, W, X>::inlineAdd(const KeyType& key, MappedPassInReferenceType mapped) 
+    HashMap<RefPtr<T>, U, V, W, X>::inlineAdd(const KeyType& key, MappedPassInReferenceType mapped)
     {
         return m_impl.template add<Translator>(key, mapped);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     inline typename HashMap<RefPtr<T>, U, V, W, X>::AddResult
-    HashMap<RefPtr<T>, U, V, W, X>::inlineAdd(RawKeyType key, MappedPassInReferenceType mapped) 
+    HashMap<RefPtr<T>, U, V, W, X>::inlineAdd(RawKeyType key, MappedPassInReferenceType mapped)
     {
         return m_impl.template add<Translator>(key, mapped);
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     typename HashMap<RefPtr<T>, U, V, W, X>::AddResult
-    HashMap<RefPtr<T>, U, V, W, X>::set(const KeyType& key, MappedPassInType mapped) 
+    HashMap<RefPtr<T>, U, V, W, X>::set(const KeyType& key, MappedPassInType mapped)
     {
         AddResult result = inlineAdd(key, mapped);
         if (!result.isNewEntry) {
             // The inlineAdd call above found an existing hash table entry; we need to set the mapped value.
             MappedTraits::store(mapped, result.iterator->value);
         }
         return result;
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
     typename HashMap<RefPtr<T>, U, V, W, X>::AddResult
-    HashMap<RefPtr<T>, U, V, W, X>::set(RawKeyType key, MappedPassInType mapped) 
+    HashMap<RefPtr<T>, U, V, W, X>::set(RawKeyType key, MappedPassInType mapped)
     {
         AddResult result = inlineAdd(key, mapped);
         if (!result.isNewEntry) {
             // The inlineAdd call above found an existing hash table entry; we need to set the mapped value.
             MappedTraits::store(mapped, result.iterator->value);
         }
         return result;
     }
 
     template<typename T, typename U, typename V, typename W, typename X>
@@ skipping 84 matching lines @@
         if (it == end())
             return MappedTraits::passOut(MappedTraits::emptyValue());
         MappedPassOutType result = MappedTraits::passOut(it->value);
         remove(it);
         return result;
     }
 
 } // namespace WTF
 
 #endif // RefPtrHashMap_h