reflow comments in modules/{webaudio,vr}

third_party/WebKit/Source/modules/webaudio/AudioScheduledSourceNode.cpp

 /*
  * Copyright (C) 2012, 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 54 matching lines @@
   // startFrame            : Start frame for this source.
   // endFrame              : End frame for this source.
   size_t quantumStartFrame = context()->currentSampleFrame();
   size_t quantumEndFrame = quantumStartFrame + quantumFrameSize;
   size_t startFrame =
       AudioUtilities::timeToSampleFrame(m_startTime, sampleRate);
   size_t endFrame =
       m_endTime == UnknownTime ? 0 : AudioUtilities::timeToSampleFrame(
                                          m_endTime, sampleRate);
 
-  // If we know the end time and it's already passed, then don't bother doing any more rendering this cycle.
+  // If we know the end time and it's already passed, then don't bother doing
+  // any more rendering this cycle.
   if (m_endTime != UnknownTime && endFrame <= quantumStartFrame)
     finish();
 
   PlaybackState state = playbackState();
 
   if (state == UNSCHEDULED_STATE || state == FINISHED_STATE ||
       startFrame >= quantumEndFrame) {
     // Output silence.
     outputBus->zero();
     nonSilentFramesToProcess = 0;
     return;
   }
 
   // Check if it's time to start playing.
   if (state == SCHEDULED_STATE) {
-    // Increment the active source count only if we're transitioning from SCHEDULED_STATE to PLAYING_STATE.
+    // Increment the active source count only if we're transitioning from
+    // SCHEDULED_STATE to PLAYING_STATE.
     setPlaybackState(PLAYING_STATE);
   }
 
   quantumFrameOffset =
       startFrame > quantumStartFrame ? startFrame - quantumStartFrame : 0;
   quantumFrameOffset =
       std::min(quantumFrameOffset, quantumFrameSize);  // clamp to valid range
   nonSilentFramesToProcess = quantumFrameSize - quantumFrameOffset;
 
   if (!nonSilentFramesToProcess) {
     // Output silence.
     outputBus->zero();
     return;
   }
 
   // Handle silence before we start playing.
-  // Zero any initial frames representing silence leading up to a rendering start time in the middle of the quantum.
+  // Zero any initial frames representing silence leading up to a rendering
+  // start time in the middle of the quantum.
   if (quantumFrameOffset) {
     for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i)
       memset(outputBus->channel(i)->mutableData(), 0,
              sizeof(float) * quantumFrameOffset);
   }
 
   // Handle silence after we're done playing.
-  // If the end time is somewhere in the middle of this time quantum, then zero out the
-  // frames from the end time to the very end of the quantum.
+  // If the end time is somewhere in the middle of this time quantum, then zero
+  // out the frames from the end time to the very end of the quantum.
   if (m_endTime != UnknownTime && endFrame >= quantumStartFrame &&
       endFrame < quantumEndFrame) {
     size_t zeroStartFrame = endFrame - quantumStartFrame;
     size_t framesToZero = quantumFrameSize - zeroStartFrame;
 
     bool isSafe = zeroStartFrame < quantumFrameSize &&
                   framesToZero <= quantumFrameSize &&
                   zeroStartFrame + framesToZero <= quantumFrameSize;
     DCHECK(isSafe);
 
@@ skipping 27 matching lines @@
     return;
   }
 
   if (when < 0) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         ExceptionMessages::indexExceedsMinimumBound("start time", when, 0.0));
     return;
   }
 
-  // The node is started. Add a reference to keep us alive so that audio will eventually get
-  // played even if Javascript should drop all references to this node. The reference will get
-  // dropped when the source has finished playing.
+  // The node is started. Add a reference to keep us alive so that audio will
+  // eventually get played even if Javascript should drop all references to this
+  // node. The reference will get dropped when the source has finished playing.
   context()->notifySourceNodeStartedProcessing(node());
 
-  // This synchronizes with process(). updateSchedulingInfo will read some of the variables being
-  // set here.
+  // This synchronizes with process(). updateSchedulingInfo will read some of
+  // the variables being set here.
   MutexLocker processLocker(m_processLock);
 
   // If |when| < currentTime, the source must start now according to the spec.
   // So just set startTime to currentTime in this case to start the source now.
   m_startTime = std::max(when, context()->currentTime());
 
   setPlaybackState(SCHEDULED_STATE);
 }
 
 void AudioScheduledSourceHandler::stop(double when,
                                        ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
   if (playbackState() == UNSCHEDULED_STATE) {
     exceptionState.throwDOMException(
         InvalidStateError, "cannot call stop without calling start first.");
     return;
   }
 
   if (when < 0) {
     exceptionState.throwDOMException(
         InvalidAccessError,
         ExceptionMessages::indexExceedsMinimumBound("stop time", when, 0.0));
     return;
   }
 
   // This synchronizes with process()
   MutexLocker processLocker(m_processLock);
 
-  // stop() can be called more than once, with the last call to stop taking effect, unless the
-  // source has already stopped due to earlier calls to stop. No exceptions are thrown in any
-  // case.
+  // stop() can be called more than once, with the last call to stop taking
+  // effect, unless the source has already stopped due to earlier calls to stop.
+  // No exceptions are thrown in any case.
   when = std::max(0.0, when);
   m_endTime = when;
 }
 
 void AudioScheduledSourceHandler::finishWithoutOnEnded() {
   if (playbackState() != FINISHED_STATE) {
     // Let the context dereference this AudioNode.
     context()->notifySourceNodeFinishedProcessing(this);
     setPlaybackState(FINISHED_STATE);
   }
@@ skipping 57 matching lines @@
   // playback state if the context is closed.
   if (context()->isContextClosed())
     return false;
 
   // If a node is scheduled or playing, do not collect the node prematurely
   // even its reference is out of scope. Then fire onended event if assigned.
   return audioScheduledSourceHandler().isPlayingOrScheduled();
 }
 
 }  // namespace blink