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

Source/wtf/PassOwnPtr.h

Index: Source/wtf/PassOwnPtr.h
diff --git a/Source/wtf/PassOwnPtr.h b/Source/wtf/PassOwnPtr.h
index 4afb0e48f2d00a8fe1432129e0f367cc04e9008e..c379f2fd3d6777b6be6f0202f08953e2e1faaf65 100644
--- a/Source/wtf/PassOwnPtr.h
+++ b/Source/wtf/PassOwnPtr.h
@@ -20,7 +20,7 @@
  * 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 WTF_PassOwnPtr_h
@@ -93,54 +93,54 @@ namespace WTF {
         return ptr;
     }
 
-    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, const PassOwnPtr<U>& b) 
+    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, const PassOwnPtr<U>& b)
     {
-        return a.get() == b.get(); 
+        return a.get() == b.get();
     }
 
-    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, const OwnPtr<U>& b) 
+    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, const OwnPtr<U>& b)
     {
-        return a.get() == b.get(); 
+        return a.get() == b.get();
     }
-    
-    template<typename T, typename U> inline bool operator==(const OwnPtr<T>& a, const PassOwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator==(const OwnPtr<T>& a, const PassOwnPtr<U>& b)
     {
-        return a.get() == b.get(); 
+        return a.get() == b.get();
     }
-    
-    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, U* b) 
+
+    template<typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, U* b)
     {
-        return a.get() == b; 
+        return a.get() == b;
     }
-    
-    template<typename T, typename U> inline bool operator==(T* a, const PassOwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator==(T* a, const PassOwnPtr<U>& b)
     {
-        return a == b.get(); 
+        return a == b.get();
     }
-    
-    template<typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, const PassOwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, const PassOwnPtr<U>& b)
     {
-        return a.get() != b.get(); 
+        return a.get() != b.get();
     }
-    
-    template<typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, const OwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, const OwnPtr<U>& b)
     {
-        return a.get() != b.get(); 
+        return a.get() != b.get();
     }
-    
-    template<typename T, typename U> inline bool operator!=(const OwnPtr<T>& a, const PassOwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator!=(const OwnPtr<T>& a, const PassOwnPtr<U>& b)
     {
-        return a.get() != b.get(); 
+        return a.get() != b.get();
     }
-    
+
     template<typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, U* b)
     {
-        return a.get() != b; 
+        return a.get() != b;
     }
-    
-    template<typename T, typename U> inline bool operator!=(T* a, const PassOwnPtr<U>& b) 
+
+    template<typename T, typename U> inline bool operator!=(T* a, const PassOwnPtr<U>& b)
     {
-        return a != b.get(); 
+        return a != b.get();
     }
 
     template<typename T> inline PassOwnPtr<T> adoptPtr(T* ptr)
@@ -148,12 +148,12 @@ namespace WTF {
         return PassOwnPtr<T>(ptr);
     }
 
-    template<typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p) 
+    template<typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p)
     {
         return adoptPtr(static_cast<T*>(p.leakPtr()));
     }
 
-    template<typename T, typename U> inline PassOwnPtr<T> const_pointer_cast(const PassOwnPtr<U>& p) 
+    template<typename T, typename U> inline PassOwnPtr<T> const_pointer_cast(const PassOwnPtr<U>& p)
     {
         return adoptPtr(const_cast<T*>(p.leakPtr()));
     }