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

Source/wtf/ThreadingPthreads.cpp

 /*
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
  * Copyright (C) 2011 Research In Motion Limited. 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. 
+ *     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. 
+ *     documentation and/or other materials provided with the distribution.
  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission. 
+ *     from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "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 OR ITS 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
@@ skipping 32 matching lines @@
 #endif
 
 namespace WTF {
 
 class PthreadState {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     enum JoinableState {
         Joinable, // The default thread state. The thread can be joined on.
 
-        Joined, // Somebody waited on this thread to exit and this thread finally exited. This state is here because there can be a 
-                // period of time between when the thread exits (which causes pthread_join to return and the remainder of waitOnThreadCompletion to run) 
-                // and when threadDidExit is called. We need threadDidExit to take charge and delete the thread data since there's 
+        Joined, // Somebody waited on this thread to exit and this thread finally exited. This state is here because there can be a
+                // period of time between when the thread exits (which causes pthread_join to return and the remainder of waitOnThreadCompletion to run)
+                // and when threadDidExit is called. We need threadDidExit to take charge and delete the thread data since there's
                 // nobody else to pick up the slack in this case (since waitOnThreadCompletion has already returned).
 
         Detached // The thread has been detached and can no longer be joined on. At this point, the thread must take care of cleaning up after itself.
     };
 
-    // Currently all threads created by WTF start out as joinable. 
+    // Currently all threads created by WTF start out as joinable.
     PthreadState(pthread_t handle)
         : m_joinableState(Joinable)
         , m_didExit(false)
         , m_pthreadHandle(handle)
     {
     }
 
     JoinableState joinableState() { return m_joinableState; }
     pthread_t pthreadHandle() { return m_pthreadHandle; }
     void didBecomeDetached() { m_joinableState = Detached; }
@@ skipping 179 matching lines @@
         threadMap().remove(threadID);
     else
         threadMap().get(threadID)->didBecomeDetached();
 }
 
 void threadDidExit(ThreadIdentifier threadID)
 {
     MutexLocker locker(threadMapMutex());
     PthreadState* state = threadMap().get(threadID);
     ASSERT(state);
-    
+
     state->didExit();
 
     if (state->joinableState() != PthreadState::Joinable)
         threadMap().remove(threadID);
 }
 
 void yield()
 {
     sched_yield();
 }
@@ skipping 47 matching lines @@
     return false;
 }
 
 void Mutex::unlock()
 {
     int result = pthread_mutex_unlock(&m_mutex);
     ASSERT_UNUSED(result, !result);
 }
 
 ThreadCondition::ThreadCondition()
-{ 
+{
     pthread_cond_init(&m_condition, NULL);
 }
 
 ThreadCondition::~ThreadCondition()
 {
     pthread_cond_destroy(&m_condition);
 }
-    
+
 void ThreadCondition::wait(Mutex& mutex)
 {
     int result = pthread_cond_wait(&m_condition, &mutex.impl());
     ASSERT_UNUSED(result, !result);
 }
 
 bool ThreadCondition::timedWait(Mutex& mutex, double absoluteTime)
 {
     if (absoluteTime < currentTime())
         return false;
@@ skipping 21 matching lines @@
 
 void ThreadCondition::broadcast()
 {
     int result = pthread_cond_broadcast(&m_condition);
     ASSERT_UNUSED(result, !result);
 }
 
 } // namespace WTF
 
 #endif // USE(PTHREADS)