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

Source/modules/geolocation/Geolocation.cpp

 /*
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  * Copyright 2010, The Android Open Source Project
  *
  * 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.
  */
 
 #include "config.h"
 #include "modules/geolocation/Geolocation.h"
 
 #include "core/dom/Document.h"
 #include "core/page/Frame.h"
 #include "core/page/Page.h"
 #include "modules/geolocation/Geoposition.h"
 #include "wtf/CurrentTime.h"
 
 #include "modules/geolocation/Coordinates.h"
 #include "modules/geolocation/GeolocationController.h"
 #include "modules/geolocation/GeolocationError.h"
 #include "modules/geolocation/GeolocationPosition.h"
 #include "modules/geolocation/PositionError.h"
 
 namespace WebCore {
 
 static const char permissionDeniedErrorMessage[] = "User denied Geolocation";
 static const char failedToStartServiceErrorMessage[] = "Failed to start Geolocation service";
 static const char framelessDocumentErrorMessage[] = "Geolocation cannot be used in frameless documents";
 
 static PassRefPtr<Geoposition> createGeoposition(GeolocationPosition* position)
 {
     if (!position)
         return 0;
-    
-    RefPtr<Coordinates> coordinates = Coordinates::create(position->latitude(), position->longitude(), position->canProvideAltitude(), position->altitude(), 
+
+    RefPtr<Coordinates> coordinates = Coordinates::create(position->latitude(), position->longitude(), position->canProvideAltitude(), position->altitude(),
                                                           position->accuracy(), position->canProvideAltitudeAccuracy(), position->altitudeAccuracy(),
                                                           position->canProvideHeading(), position->heading(), position->canProvideSpeed(), position->speed());
     return Geoposition::create(coordinates.release(), convertSecondsToDOMTimeStamp(position->timestamp()));
 }
 
 static PassRefPtr<PositionError> createPositionError(GeolocationError* error)
 {
     PositionError::ErrorCode code = PositionError::POSITION_UNAVAILABLE;
     switch (error->code()) {
     case GeolocationError::PermissionDenied:
@@ skipping 352 matching lines @@
 }
 
 void Geolocation::clearWatch(int watchID)
 {
     if (watchID <= 0)
         return;
 
     if (GeoNotifier* notifier = m_watchers.find(watchID))
         m_pendingForPermissionNotifiers.remove(notifier);
     m_watchers.remove(watchID);
-    
+
     if (!hasListeners())
         stopUpdating();
 }
 
 void Geolocation::setIsAllowed(bool allowed)
 {
     // Protect the Geolocation object from garbage collection during a callback.
     RefPtr<Geolocation> protect(this);
 
     // This may be due to either a new position from the service, or a cached
     // position.
     m_allowGeolocation = allowed ? Yes : No;
-    
+
     // Permission request was made during the startRequest process
     if (!m_pendingForPermissionNotifiers.isEmpty()) {
         handlePendingPermissionNotifiers();
         m_pendingForPermissionNotifiers.clear();
         return;
     }
 
     if (!isAllowed()) {
         RefPtr<PositionError> error = PositionError::create(PositionError::PERMISSION_DENIED,  ASCIILiteral(permissionDeniedErrorMessage));
         error->setIsFatal(true);
         handleError(error.get());
         m_requestsAwaitingCachedPosition.clear();
         return;
     }
 
     // If the service has a last position, use it to call back for all requests.
     // If any of the requests are waiting for permission for a cached position,
     // the position from the service will be at least as fresh.
     if (lastPosition())
         makeSuccessCallbacks();
     else
         makeCachedPositionCallbacks();
 }
 
 void Geolocation::sendError(GeoNotifierVector& notifiers, PositionError* error)
 {
      GeoNotifierVector::const_iterator end = notifiers.end();
      for (GeoNotifierVector::const_iterator it = notifiers.begin(); it != end; ++it) {
          RefPtr<GeoNotifier> notifier = *it;
-         
+
          notifier->runErrorCallback(error);
      }
 }
 
 void Geolocation::sendPosition(GeoNotifierVector& notifiers, Geoposition* position)
 {
     GeoNotifierVector::const_iterator end = notifiers.end();
     for (GeoNotifierVector::const_iterator it = notifiers.begin(); it != end; ++it)
         (*it)->runSuccessCallback(position);
 }
 
 void Geolocation::stopTimer(GeoNotifierVector& notifiers)
 {
     GeoNotifierVector::const_iterator end = notifiers.end();
     for (GeoNotifierVector::const_iterator it = notifiers.begin(); it != end; ++it)
         (*it)->stopTimer();
 }
 
 void Geolocation::stopTimersForOneShots()
 {
     GeoNotifierVector copy;
     copyToVector(m_oneShots, copy);
-    
+
     stopTimer(copy);
 }
 
 void Geolocation::stopTimersForWatchers()
 {
     GeoNotifierVector copy;
     m_watchers.getNotifiersVector(copy);
-    
+
     stopTimer(copy);
 }
 
 void Geolocation::stopTimers()
 {
     stopTimersForOneShots();
     stopTimersForWatchers();
 }
 
 void Geolocation::cancelRequests(GeoNotifierVector& notifiers)
@@ skipping 32 matching lines @@
      GeoNotifierVector::const_iterator end = src.end();
      for (GeoNotifierVector::const_iterator it = src.begin(); it != end; ++it) {
          GeoNotifier* notifier = it->get();
          dest.add(notifier);
      }
 }
 
 void Geolocation::handleError(PositionError* error)
 {
     ASSERT(error);
-    
+
     GeoNotifierVector oneShotsCopy;
     copyToVector(m_oneShots, oneShotsCopy);
 
     GeoNotifierVector watchersCopy;
     m_watchers.getNotifiersVector(watchersCopy);
 
     // Clear the lists before we make the callbacks, to avoid clearing notifiers
     // added by calls to Geolocation methods from the callbacks, and to prevent
     // further callbacks to these notifiers.
     GeoNotifierVector oneShotsWithCachedPosition;
@@ skipping 31 matching lines @@
     m_allowGeolocation = InProgress;
 
     // Ask the embedder: it maintains the geolocation challenge policy itself.
     GeolocationController::from(page)->requestPermission(this);
 }
 
 void Geolocation::makeSuccessCallbacks()
 {
     ASSERT(lastPosition());
     ASSERT(isAllowed());
-    
+
     GeoNotifierVector oneShotsCopy;
     copyToVector(m_oneShots, oneShotsCopy);
-    
+
     GeoNotifierVector watchersCopy;
     m_watchers.getNotifiersVector(watchersCopy);
-    
+
     // Clear the lists before we make the callbacks, to avoid clearing notifiers
     // added by calls to Geolocation methods from the callbacks, and to prevent
     // further callbacks to these notifiers.
     m_oneShots.clear();
 
     sendPosition(oneShotsCopy, lastPosition());
     sendPosition(watchersCopy, lastPosition());
 
     if (!hasListeners())
         stopUpdating();
@@ skipping 29 matching lines @@
 {
     Page* page = this->page();
     if (!page)
         return;
 
     GeolocationController::from(page)->removeObserver(this);
 }
 
 void Geolocation::handlePendingPermissionNotifiers()
 {
-    // While we iterate through the list, we need not worry about list being modified as the permission 
+    // While we iterate through the list, we need not worry about list being modified as the permission
     // is already set to Yes/No and no new listeners will be added to the pending list
     GeoNotifierSet::const_iterator end = m_pendingForPermissionNotifiers.end();
     for (GeoNotifierSet::const_iterator iter = m_pendingForPermissionNotifiers.begin(); iter != end; ++iter) {
         GeoNotifier* notifier = iter->get();
 
         if (isAllowed()) {
             // start all pending notification requests as permission granted.
             // The notifier is always ref'ed by m_oneShots or m_watchers.
             if (startUpdating(notifier))
                 notifier->startTimerIfNeeded();
             else
                 notifier->setFatalError(PositionError::create(PositionError::POSITION_UNAVAILABLE, ASCIILiteral(failedToStartServiceErrorMessage)));
         } else
             notifier->setFatalError(PositionError::create(PositionError::PERMISSION_DENIED, ASCIILiteral(permissionDeniedErrorMessage)));
     }
 }
 
 } // namespace WebCore