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

Source/wtf/HashTraits.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 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
@@ skipping 24 matching lines @@
     template<typename T> class OwnPtr;
     template<typename T> class PassOwnPtr;
 
     template<typename T> struct HashTraits;
 
     template<bool isInteger, typename T> struct GenericHashTraitsBase;
 
     template<typename T> struct GenericHashTraitsBase<false, T> {
         // The emptyValueIsZero flag is used to optimize allocation of empty hash tables with zeroed memory.
         static const bool emptyValueIsZero = false;
-        
+
         // The hasIsEmptyValueFunction flag allows the hash table to automatically generate code to check
         // for the empty value when it can be done with the equality operator, but allows custom functions
         // for cases like String that need them.
         static const bool hasIsEmptyValueFunction = false;
 
         // The needsDestruction flag is used to optimize destruction and rehashing.
         static const bool needsDestruction = true;
 
         // The starting table size. Can be overridden when we know beforehand that
         // a hash table will have at least N entries.
@@ skipping 13 matching lines @@
         typedef T EmptyValueType;
 
         static T emptyValue() { return T(); }
 
         // Type for functions that take ownership, such as add.
         // The store function either not be called or called once to store something passed in.
         // The value passed to the store function will be either PassInType or PassInType&.
         typedef const T& PassInType;
         static void store(const T& value, T& storage) { storage = value; }
 
-        // Type for return value of functions that transfer ownership, such as take. 
+        // Type for return value of functions that transfer ownership, such as take.
         typedef T PassOutType;
         static PassOutType passOut(const T& value) { return value; }
         static T& passOut(T& value) { return value; } // Overloaded to avoid copying of non-temporary values.
 
         // Type for return value of functions that do not transfer ownership, such as get.
         // FIXME: We could change this type to const T& for better performance if we figured out
         // a way to handle the return value from emptyValue, which is a temporary.
         typedef T PeekType;
         static PeekType peek(const T& value) { return value; }
         static T& peek(T& value) { return value; } // Overloaded to avoid copying of non-temporary values.
@@ skipping 158 matching lines @@
     };
 
 } // namespace WTF
 
 using WTF::HashTraits;
 using WTF::PairHashTraits;
 using WTF::NullableHashTraits;
 using WTF::SimpleClassHashTraits;
 
 #endif // WTF_HashTraits_h