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

Source/modules/webaudio/AudioContext.cpp

 /*
  * Copyright (C) 2010, Google 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
@@ skipping 64 matching lines @@
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/text/WTFString.h"
 
 // FIXME: check the proper way to reference an undefined thread ID
 const int UndefinedThreadIdentifier = 0xffffffff;
 
 const unsigned MaxNodesToDeletePerQuantum = 10;
 
 namespace WebCore {
-    
+
 bool AudioContext::isSampleRateRangeGood(float sampleRate)
 {
     // FIXME: It would be nice if the minimum sample-rate could be less than 44.1KHz,
     // but that will require some fixes in HRTFPanner::fftSizeForSampleRate(), and some testing there.
     return sampleRate >= 44100 && sampleRate <= 96000;
 }
 
 // Don't allow more than this number of simultaneous AudioContexts talking to hardware.
 const unsigned MaxHardwareContexts = 4;
 unsigned AudioContext::s_hardwareContextCount = 0;
-    
+
 PassRefPtr<AudioContext> AudioContext::create(Document* document)
 {
     ASSERT(document);
     ASSERT(isMainThread());
     if (s_hardwareContextCount >= MaxHardwareContexts)
         return 0;
 
     RefPtr<AudioContext> audioContext(adoptRef(new AudioContext(document)));
     audioContext->suspendIfNeeded();
     return audioContext.release();
@@ skipping 85 matching lines @@
         ASSERT(!m_isAudioThreadFinished);
         if (!m_isAudioThreadFinished) {
             if (m_destinationNode.get()) {
                 m_destinationNode->initialize();
 
                 if (!isOfflineContext()) {
                     // This starts the audio thread. The destination node's provideInput() method will now be called repeatedly to render audio.
                     // Each time provideInput() is called, a portion of the audio stream is rendered. Let's call this time period a "render quantum".
                     // NOTE: for now default AudioContext does not need an explicit startRendering() call from JavaScript.
                     // We may want to consider requiring it for symmetry with OfflineAudioContext.
-                    m_destinationNode->startRendering();                    
+                    m_destinationNode->startRendering();
                     ++s_hardwareContextCount;
                 }
 
             }
             m_isInitialized = true;
         }
     }
 }
 
 void AudioContext::clear()
@@ skipping 39 matching lines @@
 
 bool AudioContext::isInitialized() const
 {
     return m_isInitialized;
 }
 
 bool AudioContext::isRunnable() const
 {
     if (!isInitialized())
         return false;
-    
+
     // Check with the HRTF spatialization system to see if it's finished loading.
     return m_hrtfDatabaseLoader->isLoaded();
 }
 
 void AudioContext::stopDispatch(void* userData)
 {
     AudioContext* context = reinterpret_cast<AudioContext*>(userData);
     ASSERT(context);
     if (!context)
         return;
@@ skipping 66 matching lines @@
     return node;
 }
 
 PassRefPtr<MediaElementAudioSourceNode> AudioContext::createMediaElementSource(HTMLMediaElement* mediaElement, ExceptionState& es)
 {
     ASSERT(mediaElement);
     if (!mediaElement) {
         es.throwDOMException(InvalidStateError);
         return 0;
     }
-        
+
     ASSERT(isMainThread());
     lazyInitialize();
-    
+
     // First check if this media element already has a source node.
     if (mediaElement->audioSourceNode()) {
         es.throwDOMException(InvalidStateError);
         return 0;
     }
-        
+
     RefPtr<MediaElementAudioSourceNode> node = MediaElementAudioSourceNode::create(this, mediaElement);
 
     mediaElement->setAudioSourceNode(node.get());
 
     refNode(node.get()); // context keeps reference until node is disconnected
     return node;
 }
 
 PassRefPtr<MediaStreamAudioSourceNode> AudioContext::createMediaStreamSource(MediaStream* mediaStream, ExceptionState& es)
 {
@@ skipping 181 matching lines @@
     // Because this is an AudioScheduledSourceNode, the context keeps a reference until it has finished playing.
     // When this happens, AudioScheduledSourceNode::finish() calls AudioContext::notifyNodeFinishedProcessing().
     refNode(node.get());
 
     return node;
 }
 
 PassRefPtr<PeriodicWave> AudioContext::createPeriodicWave(Float32Array* real, Float32Array* imag, ExceptionState& es)
 {
     ASSERT(isMainThread());
-    
+
     if (!real || !imag || (real->length() != imag->length())) {
         es.throwDOMException(SyntaxError);
         return 0;
     }
-    
+
     lazyInitialize();
     return PeriodicWave::create(sampleRate(), real, imag);
 }
 
 void AudioContext::notifyNodeFinishedProcessing(AudioNode* node)
 {
     ASSERT(isAudioThread());
     m_finishedNodes.append(node);
 }
 
 void AudioContext::derefFinishedSourceNodes()
 {
     ASSERT(isGraphOwner());
     ASSERT(isAudioThread() || isAudioThreadFinished());
     for (unsigned i = 0; i < m_finishedNodes.size(); i++)
         derefNode(m_finishedNodes[i]);
 
     m_finishedNodes.clear();
 }
 
 void AudioContext::refNode(AudioNode* node)
 {
     ASSERT(isMainThread());
     AutoLocker locker(this);
-    
+
     node->ref(AudioNode::RefTypeConnection);
     m_referencedNodes.append(node);
 }
 
 void AudioContext::derefNode(AudioNode* node)
 {
     ASSERT(isGraphOwner());
-    
+
     node->deref(AudioNode::RefTypeConnection);
 
     for (unsigned i = 0; i < m_referencedNodes.size(); ++i) {
         if (node == m_referencedNodes[i]) {
             m_referencedNodes.remove(i);
             break;
         }
     }
 }
 
@@ skipping 24 matching lines @@
     }
 }
 
 bool AudioContext::tryLock(bool& mustReleaseLock)
 {
     ThreadIdentifier thisThread = currentThread();
     bool isAudioThread = thisThread == audioThread();
 
     // Try to catch cases of using try lock on main thread - it should use regular lock.
     ASSERT(isAudioThread || isAudioThreadFinished());
-    
+
     if (!isAudioThread) {
         // In release build treat tryLock() as lock() (since above ASSERT(isAudioThread) never fires) - this is the best we can do.
         lock(mustReleaseLock);
         return true;
     }
-    
+
     bool hasLock;
-    
+
     if (thisThread == m_graphOwnerThread) {
         // Thread already has the lock.
         hasLock = true;
         mustReleaseLock = false;
     } else {
         // Don't already have the lock - try to acquire it.
         hasLock = m_contextGraphMutex.tryLock();
-        
+
         if (hasLock)
             m_graphOwnerThread = thisThread;
 
         mustReleaseLock = hasLock;
     }
-    
+
     return hasLock;
 }
 
 void AudioContext::unlock()
 {
     ASSERT(currentThread() == m_graphOwnerThread);
 
     m_graphOwnerThread = UndefinedThreadIdentifier;
     m_contextGraphMutex.unlock();
 }
@@ skipping 10 matching lines @@
 
 void AudioContext::addDeferredFinishDeref(AudioNode* node)
 {
     ASSERT(isAudioThread());
     m_deferredFinishDerefList.append(node);
 }
 
 void AudioContext::handlePreRenderTasks()
 {
     ASSERT(isAudioThread());
- 
+
     // At the beginning of every render quantum, try to update the internal rendering graph state (from main thread changes).
     // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
     bool mustReleaseLock;
     if (tryLock(mustReleaseLock)) {
         // Fixup the state of any dirty AudioSummingJunctions and AudioNodeOutputs.
         handleDirtyAudioSummingJunctions();
         handleDirtyAudioNodeOutputs();
 
         updateAutomaticPullNodes();
 
         if (mustReleaseLock)
             unlock();
     }
 }
 
 void AudioContext::handlePostRenderTasks()
 {
     ASSERT(isAudioThread());
- 
+
     // Must use a tryLock() here too.  Don't worry, the lock will very rarely be contended and this method is called frequently.
     // The worst that can happen is that there will be some nodes which will take slightly longer than usual to be deleted or removed
     // from the render graph (in which case they'll render silence).
     bool mustReleaseLock;
     if (tryLock(mustReleaseLock)) {
         // Take care of finishing any derefs where the tryLock() failed previously.
         handleDeferredFinishDerefs();
 
         // Dynamically clean up nodes which are no longer needed.
         derefFinishedSourceNodes();
@@ skipping 13 matching lines @@
     }
 }
 
 void AudioContext::handleDeferredFinishDerefs()
 {
     ASSERT(isAudioThread() && isGraphOwner());
     for (unsigned i = 0; i < m_deferredFinishDerefList.size(); ++i) {
         AudioNode* node = m_deferredFinishDerefList[i];
         node->finishDeref(AudioNode::RefTypeConnection);
     }
-    
+
     m_deferredFinishDerefList.clear();
 }
 
 void AudioContext::markForDeletion(AudioNode* node)
 {
     ASSERT(isGraphOwner());
 
     if (isAudioThreadFinished())
         m_nodesToDelete.append(node);
     else
         m_nodesMarkedForDeletion.append(node);
 
     // This is probably the best time for us to remove the node from automatic pull list,
     // since all connections are gone and we hold the graph lock. Then when handlePostRenderTasks()
     // gets a chance to schedule the deletion work, updateAutomaticPullNodes() also gets a chance to
     // modify m_renderingAutomaticPullNodes.
     removeAutomaticPullNode(node);
 }
 
 void AudioContext::scheduleNodeDeletion()
 {
     bool isGood = m_isInitialized && isGraphOwner();
     ASSERT(isGood);
     if (!isGood)
         return;
 
-    // Make sure to call deleteMarkedNodes() on main thread.    
+    // Make sure to call deleteMarkedNodes() on main thread.
     if (m_nodesMarkedForDeletion.size() && !m_isDeletionScheduled) {
         m_nodesToDelete.append(m_nodesMarkedForDeletion);
         m_nodesMarkedForDeletion.clear();
 
         m_isDeletionScheduled = true;
 
         // Don't let ourself get deleted before the callback.
         // See matching deref() in deleteMarkedNodesDispatch().
         ref();
         callOnMainThread(deleteMarkedNodesDispatch, this);
@@ skipping 36 matching lines @@
 
             // Finally, delete it.
             delete node;
         }
         m_isDeletionScheduled = false;
     }
 }
 
 void AudioContext::markSummingJunctionDirty(AudioSummingJunction* summingJunction)
 {
-    ASSERT(isGraphOwner());    
+    ASSERT(isGraphOwner());
     m_dirtySummingJunctions.add(summingJunction);
 }
 
 void AudioContext::removeMarkedSummingJunction(AudioSummingJunction* summingJunction)
 {
     ASSERT(isMainThread());
     AutoLocker locker(this);
     m_dirtySummingJunctions.remove(summingJunction);
 }
 
 void AudioContext::markAudioNodeOutputDirty(AudioNodeOutput* output)
 {
-    ASSERT(isGraphOwner());    
+    ASSERT(isGraphOwner());
     m_dirtyAudioNodeOutputs.add(output);
 }
 
 void AudioContext::handleDirtyAudioSummingJunctions()
 {
-    ASSERT(isGraphOwner());    
+    ASSERT(isGraphOwner());
 
     for (HashSet<AudioSummingJunction*>::iterator i = m_dirtySummingJunctions.begin(); i != m_dirtySummingJunctions.end(); ++i)
         (*i)->updateRenderingState();
 
     m_dirtySummingJunctions.clear();
 }
 
 void AudioContext::handleDirtyAudioNodeOutputs()
 {
-    ASSERT(isGraphOwner());    
+    ASSERT(isGraphOwner());
 
     for (HashSet<AudioNodeOutput*>::iterator i = m_dirtyAudioNodeOutputs.begin(); i != m_dirtyAudioNodeOutputs.end(); ++i)
         (*i)->updateRenderingState();
 
     m_dirtyAudioNodeOutputs.clear();
 }
 
 void AudioContext::addAutomaticPullNode(AudioNode* node)
 {
     ASSERT(isGraphOwner());
@@ skipping 53 matching lines @@
 void AudioContext::startRendering()
 {
     destination()->startRendering();
 }
 
 void AudioContext::fireCompletionEvent()
 {
     ASSERT(isMainThread());
     if (!isMainThread())
         return;
-        
+
     AudioBuffer* renderedBuffer = m_renderTarget.get();
 
     ASSERT(renderedBuffer);
     if (!renderedBuffer)
         return;
 
     // Avoid firing the event if the document has already gone away.
     if (scriptExecutionContext()) {
         // Call the offline rendering completion event listener.
         dispatchEvent(OfflineAudioCompletionEvent::create(renderedBuffer));
     }
 }
 
 void AudioContext::incrementActiveSourceCount()
 {
     atomicIncrement(&m_activeSourceCount);
 }
 
 void AudioContext::decrementActiveSourceCount()
 {
     atomicDecrement(&m_activeSourceCount);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)