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

Source/modules/webaudio/ScriptProcessorNode.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 121 matching lines @@
     AudioNode::uninitialize();
 }
 
 void ScriptProcessorNode::process(size_t framesToProcess)
 {
     // Discussion about inputs and outputs:
     // As in other AudioNodes, ScriptProcessorNode uses an AudioBus for its input and output (see inputBus and outputBus below).
     // Additionally, there is a double-buffering for input and output which is exposed directly to JavaScript (see inputBuffer and outputBuffer below).
     // This node is the producer for inputBuffer and the consumer for outputBuffer.
     // The JavaScript code is the consumer of inputBuffer and the producer for outputBuffer.
-    
+
     // Get input and output busses.
     AudioBus* inputBus = this->input(0)->bus();
     AudioBus* outputBus = this->output(0)->bus();
 
     // Get input and output buffers. We double-buffer both the input and output sides.
     unsigned doubleBufferIndex = this->doubleBufferIndex();
     bool isDoubleBufferIndexGood = doubleBufferIndex < 2 && doubleBufferIndex < m_inputBuffers.size() && doubleBufferIndex < m_outputBuffers.size();
     ASSERT(isDoubleBufferIndexGood);
     if (!isDoubleBufferIndexGood)
         return;
-    
+
     AudioBuffer* inputBuffer = m_inputBuffers[doubleBufferIndex].get();
     AudioBuffer* outputBuffer = m_outputBuffers[doubleBufferIndex].get();
 
     // Check the consistency of input and output buffers.
     unsigned numberOfInputChannels = m_internalInputBus->numberOfChannels();
     bool buffersAreGood = outputBuffer && bufferSize() == outputBuffer->length() && m_bufferReadWriteIndex + framesToProcess <= bufferSize();
 
     // If the number of input channels is zero, it's ok to have inputBuffer = 0.
     if (m_internalInputBus->numberOfChannels())
         buffersAreGood = buffersAreGood && inputBuffer && bufferSize() == inputBuffer->length();
@@ skipping 14 matching lines @@
     ASSERT(channelsAreGood);
     if (!channelsAreGood)
         return;
 
     for (unsigned i = 0; i < numberOfInputChannels; i++)
         m_internalInputBus->setChannelMemory(i, inputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, framesToProcess);
 
     if (numberOfInputChannels)
         m_internalInputBus->copyFrom(*inputBus);
 
-    // Copy from the output buffer to the output. 
+    // Copy from the output buffer to the output.
     for (unsigned i = 0; i < numberOfOutputChannels; ++i)
         memcpy(outputBus->channel(i)->mutableData(), outputBuffer->getChannelData(i)->data() + m_bufferReadWriteIndex, sizeof(float) * framesToProcess);
 
     // Update the buffering index.
     m_bufferReadWriteIndex = (m_bufferReadWriteIndex + framesToProcess) % bufferSize();
 
     // m_bufferReadWriteIndex will wrap back around to 0 when the current input and output buffers are full.
     // When this happens, fire an event and swap buffers.
     if (!m_bufferReadWriteIndex) {
         // Avoid building up requests on the main thread to fire process events when they're not being handled.
         // This could be a problem if the main thread is very busy doing other things and is being held up handling previous requests.
         if (m_isRequestOutstanding) {
             // We're late in handling the previous request. The main thread must be very busy.
             // The best we can do is clear out the buffer ourself here.
-            outputBuffer->zero();            
+            outputBuffer->zero();
         } else {
             // Reference ourself so we don't accidentally get deleted before fireProcessEvent() gets called.
             ref();
-            
+
             // Fire the event on the main thread, not this one (which is the realtime audio thread).
             m_doubleBufferIndexForEvent = m_doubleBufferIndex;
             m_isRequestOutstanding = true;
             callOnMainThread(fireProcessEventDispatch, this);
         }
 
         swapBuffers();
     }
 }
 
 void ScriptProcessorNode::fireProcessEventDispatch(void* userData)
 {
     ScriptProcessorNode* jsAudioNode = static_cast<ScriptProcessorNode*>(userData);
     ASSERT(jsAudioNode);
     if (!jsAudioNode)
         return;
 
     jsAudioNode->fireProcessEvent();
 
     // De-reference to match the ref() call in process().
     jsAudioNode->deref();
 }
 
 void ScriptProcessorNode::fireProcessEvent()
 {
     ASSERT(isMainThread() && m_isRequestOutstanding);
-    
+
     bool isIndexGood = m_doubleBufferIndexForEvent < 2;
     ASSERT(isIndexGood);
     if (!isIndexGood)
         return;
-        
+
     AudioBuffer* inputBuffer = m_inputBuffers[m_doubleBufferIndexForEvent].get();
     AudioBuffer* outputBuffer = m_outputBuffers[m_doubleBufferIndexForEvent].get();
     ASSERT(outputBuffer);
     if (!outputBuffer)
         return;
 
     // Avoid firing the event if the document has already gone away.
     if (context()->scriptExecutionContext()) {
         // Let the audio thread know we've gotten to the point where it's OK for it to make another request.
         m_isRequestOutstanding = false;
-        
+
         // Call the JavaScript event handler which will do the audio processing.
         dispatchEvent(AudioProcessingEvent::create(inputBuffer, outputBuffer));
     }
 }
 
 void ScriptProcessorNode::reset()
 {
     m_bufferReadWriteIndex = 0;
     m_doubleBufferIndex = 0;
 
     for (unsigned i = 0; i < 2; ++i) {
         m_inputBuffers[i]->zero();
         m_outputBuffers[i]->zero();
     }
 }
 
 double ScriptProcessorNode::tailTime() const
 {
     return std::numeric_limits<double>::infinity();
 }
 
 double ScriptProcessorNode::latencyTime() const
 {
     return std::numeric_limits<double>::infinity();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)