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

Source/wtf/CheckedArithmetic.h

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CheckedArithmetic_h
 #define CheckedArithmetic_h
 
 #include "wtf/Assertions.h"
 #include "wtf/EnumClass.h"
 #include "wtf/TypeTraits.h"
 
 #include <limits>
@@ skipping 31 matching lines @@
  *
  */
 
 namespace WTF {
 
 ENUM_CLASS(CheckedState)
 {
     DidOverflow,
     DidNotOverflow
 } ENUM_CLASS_END(CheckedState);
-    
+
 class CrashOnOverflow {
 protected:
     NO_RETURN_DUE_TO_CRASH void overflowed()
     {
         CRASH();
     }
 
     void clearOverflow() { }
 
 public:
@@ skipping 48 matching lines @@
 };
 
 template <typename Target, typename Source> struct BoundsChecker<Target, Source, false, true> {
     static bool inBounds(Source value)
     {
         // Target is unsigned so any value less than zero is clearly unsafe
         if (value < 0)
             return false;
         // If our (unsigned) Target is the same or greater width we can
         // convert value to type Target without losing precision
-        if (sizeof(Target) >= sizeof(Source)) 
+        if (sizeof(Target) >= sizeof(Source))
             return static_cast<Target>(value) <= std::numeric_limits<Target>::max();
         // The signed Source type has greater precision than the target so
         // max(Target) -> Source will widen.
         return value <= static_cast<Source>(std::numeric_limits<Target>::max());
     }
 };
 
 template <typename Target, typename Source> struct BoundsChecker<Target, Source, true, false> {
     static bool inBounds(Source value)
     {
         // Signed target with an unsigned source
-        if (sizeof(Target) <= sizeof(Source)) 
+        if (sizeof(Target) <= sizeof(Source))
             return value <= static_cast<Source>(std::numeric_limits<Target>::max());
         // Target is Wider than Source so we're guaranteed to fit any value in
         // unsigned Source
         return true;
     }
 };
 
 template <typename Target, typename Source, bool CanElide = IsSameType<Target, Source>::value || (sizeof(Target) > sizeof(Source)) > struct BoundsCheckElider;
 template <typename Target, typename Source> struct BoundsCheckElider<Target, Source, true> {
     static bool inBounds(Source) { return true; }
 };
 template <typename Target, typename Source> struct BoundsCheckElider<Target, Source, false> : public BoundsChecker<Target, Source> {
 };
 
 template <typename Target, typename Source> static inline bool isInBounds(Source value)
 {
     return BoundsCheckElider<Target, Source>::inBounds(value);
 }
 
 template <typename T> struct RemoveChecked {
     typedef T CleanType;
-    static const CleanType DefaultValue = 0;    
+    static const CleanType DefaultValue = 0;
 };
 
 template <typename T> struct RemoveChecked<Checked<T, CrashOnOverflow> > {
     typedef typename RemoveChecked<T>::CleanType CleanType;
     static const CleanType DefaultValue = 0;
 };
 
 template <typename T> struct RemoveChecked<Checked<T, RecordOverflow> > {
     typedef typename RemoveChecked<T>::CleanType CleanType;
     static const CleanType DefaultValue = 0;
@@ skipping 31 matching lines @@
     typedef U ResultType;
 };
 
 template <typename U, typename V> struct ResultBase<U, V, false, true> {
     typedef typename SignednessSelector<U, V>::ResultType ResultType;
 };
 
 template <typename U, typename V> struct Result : ResultBase<typename RemoveChecked<U>::CleanType, typename RemoveChecked<V>::CleanType> {
 };
 
-template <typename LHS, typename RHS, typename ResultType = typename Result<LHS, RHS>::ResultType, 
+template <typename LHS, typename RHS, typename ResultType = typename Result<LHS, RHS>::ResultType,
     bool lhsSigned = std::numeric_limits<LHS>::is_signed, bool rhsSigned = std::numeric_limits<RHS>::is_signed> struct ArithmeticOperations;
 
 template <typename LHS, typename RHS, typename ResultType> struct ArithmeticOperations<LHS, RHS, ResultType, true, true> {
     // LHS and RHS are signed types
 
     // Helper function
     static inline bool signsMatch(LHS lhs, RHS rhs)
     {
         return (lhs ^ rhs) >= 0;
     }
@@ skipping 98 matching lines @@
     static inline bool add(int64_t lhs, int64_t rhs, ResultType& result)
     {
         int64_t temp = lhs + rhs;
         if (temp < std::numeric_limits<ResultType>::min())
             return false;
         if (temp > std::numeric_limits<ResultType>::max())
             return false;
         result = static_cast<ResultType>(temp);
         return true;
     }
-    
+
     static inline bool sub(int64_t lhs, int64_t rhs, ResultType& result)
     {
         int64_t temp = lhs - rhs;
         if (temp < std::numeric_limits<ResultType>::min())
             return false;
         if (temp > std::numeric_limits<ResultType>::max())
             return false;
         result = static_cast<ResultType>(temp);
         return true;
     }
@@ skipping 13 matching lines @@
     {
         return static_cast<int64_t>(lhs) == static_cast<int64_t>(rhs);
     }
 };
 
 template <typename ResultType> struct ArithmeticOperations<unsigned, int, ResultType, false, true> {
     static inline bool add(int64_t lhs, int64_t rhs, ResultType& result)
     {
         return ArithmeticOperations<int, unsigned, ResultType>::add(rhs, lhs, result);
     }
-    
+
     static inline bool sub(int64_t lhs, int64_t rhs, ResultType& result)
     {
         return ArithmeticOperations<int, unsigned, ResultType>::sub(lhs, rhs, result);
     }
 
     static inline bool multiply(int64_t lhs, int64_t rhs, ResultType& result)
     {
         return ArithmeticOperations<int, unsigned, ResultType>::multiply(rhs, lhs, result);
     }
 
@@ skipping 17 matching lines @@
 {
     return ArithmeticOperations<U, V, R>::multiply(lhs, rhs, result);
 }
 
 template <typename U, typename V> static inline bool safeEquals(U lhs, V rhs)
 {
     return ArithmeticOperations<U, V>::equals(lhs, rhs);
 }
 
 enum ResultOverflowedTag { ResultOverflowed };
-    
+
 // FIXME: Needed to workaround http://llvm.org/bugs/show_bug.cgi?id=10801
 static inline bool workAroundClangBug() { return true; }
 
 template <typename T, class OverflowHandler> class Checked : public OverflowHandler {
 public:
     template <typename _T, class _OverflowHandler> friend class Checked;
     Checked()
         : m_value(0)
     {
     }
 
     Checked(ResultOverflowedTag)
         : m_value(0)
     {
         // FIXME: Remove this when clang fixes http://llvm.org/bugs/show_bug.cgi?id=10801
         if (workAroundClangBug())
             this->overflowed();
     }
 
     template <typename U> Checked(U value)
     {
         if (!isInBounds<T>(value))
             this->overflowed();
         m_value = static_cast<T>(value);
     }
-    
+
     template <typename V> Checked(const Checked<T, V>& rhs)
         : m_value(rhs.m_value)
     {
         if (rhs.hasOverflowed())
             this->overflowed();
     }
-    
+
     template <typename U> Checked(const Checked<U, OverflowHandler>& rhs)
         : OverflowHandler(rhs)
     {
         if (!isInBounds<T>(rhs.m_value))
             this->overflowed();
         m_value = static_cast<T>(rhs.m_value);
     }
-    
+
     template <typename U, typename V> Checked(const Checked<U, V>& rhs)
     {
         if (rhs.hasOverflowed())
             this->overflowed();
         if (!isInBounds<T>(rhs.m_value))
             this->overflowed();
         m_value = static_cast<T>(rhs.m_value);
     }
-    
+
     const Checked& operator=(Checked rhs)
     {
         this->clearOverflow();
         if (rhs.hasOverflowed())
             this->overflowed();
         m_value = static_cast<T>(rhs.m_value);
         return *this;
     }
-    
+
     template <typename U> const Checked& operator=(U value)
     {
         return *this = Checked(value);
     }
-    
+
     template <typename U, typename V> const Checked& operator=(const Checked<U, V>& rhs)
     {
         return *this = Checked(rhs);
     }
-    
+
     // prefix
     const Checked& operator++()
     {
         if (m_value == std::numeric_limits<T>::max())
             this->overflowed();
         m_value++;
         return *this;
     }
-    
+
     const Checked& operator--()
     {
         if (m_value == std::numeric_limits<T>::min())
             this->overflowed();
         m_value--;
         return *this;
     }
-    
+
     // postfix operators
     const Checked operator++(int)
     {
         if (m_value == std::numeric_limits<T>::max())
             this->overflowed();
         return Checked(m_value++);
     }
-    
+
     const Checked operator--(int)
     {
         if (m_value == std::numeric_limits<T>::min())
             this->overflowed();
         return Checked(m_value--);
     }
-    
+
     // Boolean operators
     bool operator!() const
     {
         if (this->hasOverflowed())
             CRASH();
         return !m_value;
     }
 
     typedef void* (Checked::*UnspecifiedBoolType);
     operator UnspecifiedBoolType*() const
     {
         if (this->hasOverflowed())
             CRASH();
         return (m_value) ? reinterpret_cast<UnspecifiedBoolType*>(1) : 0;
     }
 
     // Value accessors. unsafeGet() will crash if there's been an overflow.
     T unsafeGet() const
     {
         if (this->hasOverflowed())
             CRASH();
         return m_value;
     }
-    
+
     inline CheckedState safeGet(T& value) const WARN_UNUSED_RETURN
     {
         value = m_value;
         if (this->hasOverflowed())
             return CheckedState::DidOverflow;
         return CheckedState::DidNotOverflow;
     }
 
     // Mutating assignment
     template <typename U> const Checked operator+=(U rhs)
@@ skipping 24 matching lines @@
         if (!(std::numeric_limits<T>::min() <= result && std::numeric_limits<T>::max() >= result))
             this->overflowed();
         m_value = (T)result;
         return *this;
     }
 
     const Checked operator*=(float rhs)
     {
         return *this *= (double)rhs;
     }
-    
+
     template <typename U, typename V> const Checked operator+=(Checked<U, V> rhs)
     {
         if (rhs.hasOverflowed())
             this->overflowed();
         return *this += rhs.m_value;
     }
 
     template <typename U, typename V> const Checked operator-=(Checked<U, V> rhs)
     {
         if (rhs.hasOverflowed())
@@ skipping 13 matching lines @@
     {
         return unsafeGet() == rhs.unsafeGet();
     }
 
     template <typename U> bool operator==(U rhs)
     {
         if (this->hasOverflowed())
             this->overflowed();
         return safeEquals(m_value, rhs);
     }
-    
+
     template <typename U, typename V> const Checked operator==(Checked<U, V> rhs)
     {
         return unsafeGet() == Checked(rhs.unsafeGet());
     }
 
     template <typename U> bool operator!=(U rhs)
     {
         return !(*this == rhs);
     }
 
@@ skipping 76 matching lines @@
     return Checked<U, OverflowHandler>(lhs) * rhs;
 }
 
 }
 
 using WTF::Checked;
 using WTF::CheckedState;
 using WTF::RecordOverflow;
 
 #endif