reflow comments in modules/{webaudio,vr}

third_party/WebKit/Source/modules/webaudio/AudioParam.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
@@ skipping 31 matching lines @@
                                      AudioParamType paramType,
                                      double defaultValue,
                                      float minValue,
                                      float maxValue)
     : AudioSummingJunction(context.deferredTaskHandler()),
       m_paramType(paramType),
       m_intrinsicValue(defaultValue),
       m_defaultValue(defaultValue),
       m_minValue(minValue),
       m_maxValue(maxValue) {
-  // The destination MUST exist because we need the destination handler for the AudioParam.
+  // The destination MUST exist because we need the destination handler for the
+  // AudioParam.
   RELEASE_ASSERT(context.destination());
 
   m_destinationHandler = &context.destination()->audioDestinationHandler();
   m_timeline.setSmoothedValue(defaultValue);
 }
 
 AudioDestinationHandler& AudioParamHandler::destinationHandler() const {
   return *m_destinationHandler;
 }
 
 void AudioParamHandler::setParamType(AudioParamType paramType) {
   m_paramType = paramType;
 }
 
 String AudioParamHandler::getParamName() const {
-  // The returned string should be the name of the node and the name of the AudioParam for
-  // that node.
+  // The returned string should be the name of the node and the name of the
+  // AudioParam for that node.
   switch (m_paramType) {
     case ParamTypeAudioBufferSourcePlaybackRate:
       return "AudioBufferSource.playbackRate";
     case ParamTypeAudioBufferSourceDetune:
       return "AudioBufferSource.detune";
     case ParamTypeBiquadFilterFrequency:
       return "BiquadFilter.frequency";
     case ParamTypeBiquadFilterQ:
     case ParamTypeBiquadFilterQLowpass:
     case ParamTypeBiquadFilterQHighpass:
-      // We don't really need separate names for the Q parameter for lowpass and highpass filters.
-      // The difference is only for the histograms.
+      // We don't really need separate names for the Q parameter for lowpass and
+      // highpass filters.  The difference is only for the histograms.
       return "BiquadFilter.Q";
     case ParamTypeBiquadFilterGain:
       return "BiquadFilter.gain";
     case ParamTypeBiquadFilterDetune:
       return "BiquadFilter.detune";
     case ParamTypeDelayDelayTime:
       return "Delay.delayTime";
     case ParamTypeDynamicsCompressorThreshold:
       return "DynamicsCompressor.threshold";
     case ParamTypeDynamicsCompressorKnee:
@@ skipping 72 matching lines @@
 void AudioParamHandler::setValue(float value) {
   setIntrinsicValue(value);
   updateHistograms(value);
 }
 
 float AudioParamHandler::smoothedValue() {
   return m_timeline.smoothedValue();
 }
 
 bool AudioParamHandler::smooth() {
-  // If values have been explicitly scheduled on the timeline, then use the exact value.
-  // Smoothing effectively is performed by the timeline.
+  // If values have been explicitly scheduled on the timeline, then use the
+  // exact value.  Smoothing effectively is performed by the timeline.
   bool useTimelineValue = false;
   float value =
       m_timeline.valueForContextTime(destinationHandler(), intrinsicValue(),
                                      useTimelineValue, minValue(), maxValue());
 
   float smoothedValue = m_timeline.smoothedValue();
   if (smoothedValue == value) {
     // Smoothed value has already approached and snapped to value.
     setIntrinsicValue(value);
     return true;
@@ skipping 36 matching lines @@
 
 void AudioParamHandler::calculateFinalValues(float* values,
                                              unsigned numberOfValues,
                                              bool sampleAccurate) {
   bool isGood =
       deferredTaskHandler().isAudioThread() && values && numberOfValues;
   DCHECK(isGood);
   if (!isGood)
     return;
 
-  // The calculated result will be the "intrinsic" value summed with all audio-rate connections.
+  // The calculated result will be the "intrinsic" value summed with all
+  // audio-rate connections.
 
   if (sampleAccurate) {
     // Calculate sample-accurate (a-rate) intrinsic values.
     calculateTimelineValues(values, numberOfValues);
   } else {
     // Calculate control-rate (k-rate) intrinsic value.
     bool hasValue;
     float value = intrinsicValue();
     float timelineValue = m_timeline.valueForContextTime(
         destinationHandler(), value, hasValue, minValue(), maxValue());
 
     if (hasValue)
       value = timelineValue;
 
     values[0] = value;
     setIntrinsicValue(value);
   }
 
-  // Now sum all of the audio-rate connections together (unity-gain summing junction).
-  // Note that connections would normally be mono, but we mix down to mono if necessary.
+  // Now sum all of the audio-rate connections together (unity-gain summing
+  // junction).  Note that connections would normally be mono, but we mix down
+  // to mono if necessary.
   RefPtr<AudioBus> summingBus = AudioBus::create(1, numberOfValues, false);
   summingBus->setChannelMemory(0, values, numberOfValues);
 
   for (unsigned i = 0; i < numberOfRenderingConnections(); ++i) {
     AudioNodeOutput* output = renderingOutput(i);
     DCHECK(output);
 
     // Render audio from this output.
     AudioBus* connectionBus =
         output->pull(0, AudioHandler::ProcessingSizeInFrames);
@@ skipping 33 matching lines @@
   ASSERT(deferredTaskHandler().isGraphOwner());
 
   if (m_outputs.contains(&output)) {
     m_outputs.remove(&output);
     changedOutputs();
     output.removeParam(*this);
   }
 }
 
 int AudioParamHandler::computeQHistogramValue(float newValue) const {
-  // For the Q value, assume a useful range is [0, 25] and that 0.25 dB resolution is good enough.
-  // Then, we can map the floating point Q value (in dB) to an integer just by multipling by 4 and
-  // rounding.
+  // For the Q value, assume a useful range is [0, 25] and that 0.25 dB
+  // resolution is good enough.  Then, we can map the floating point Q value (in
+  // dB) to an integer just by multipling by 4 and rounding.
   newValue = clampTo(newValue, 0.0, 25.0);
   return static_cast<int>(4 * newValue + 0.5);
 }
 
 void AudioParamHandler::updateHistograms(float newValue) {
   switch (m_paramType) {
     case ParamTypeBiquadFilterQLowpass: {
       // The histogram for the Q value for a lowpass biquad filter.
       DEFINE_STATIC_LOCAL(SparseHistogram, lowpassQHistogram,
                           ("WebAudio.BiquadFilter.Q.Lowpass"));
@@ skipping 23 matching lines @@
     : m_handler(AudioParamHandler::create(context,
                                           paramType,
                                           defaultValue,
                                           minValue,
                                           maxValue)),
       m_context(context) {}
 
 AudioParam* AudioParam::create(BaseAudioContext& context,
                                AudioParamType paramType,
                                double defaultValue) {
-  // Default nominal range is most negative float to most positive.  This basically means any
-  // value is valid, except that floating-point infinities are excluded.
+  // Default nominal range is most negative float to most positive.  This
+  // basically means any value is valid, except that floating-point infinities
+  // are excluded.
   float limit = std::numeric_limits<float>::max();
   return new AudioParam(context, paramType, defaultValue, -limit, limit);
 }
 
 AudioParam* AudioParam::create(BaseAudioContext& context,
                                AudioParamType paramType,
                                double defaultValue,
                                float minValue,
                                float maxValue) {
   DCHECK_LE(minValue, maxValue);
@@ skipping 51 matching lines @@
 
 AudioParam* AudioParam::linearRampToValueAtTime(
     float value,
     double time,
     ExceptionState& exceptionState) {
   warnIfOutsideRange("linearRampToValueAtTime value", value);
   handler().timeline().linearRampToValueAtTime(
       value, time, handler().intrinsicValue(), context()->currentTime(),
       exceptionState);
 
-  // This is probably the best we can do for the histogram.  We don't want to run the automation
-  // to get all the values and use them to update the histogram.
+  // This is probably the best we can do for the histogram.  We don't want to
+  // run the automation to get all the values and use them to update the
+  // histogram.
   handler().updateHistograms(value);
 
   return this;
 }
 
 AudioParam* AudioParam::exponentialRampToValueAtTime(
     float value,
     double time,
     ExceptionState& exceptionState) {
   warnIfOutsideRange("exponentialRampToValue value", value);
   handler().timeline().exponentialRampToValueAtTime(
       value, time, handler().intrinsicValue(), context()->currentTime(),
       exceptionState);
 
-  // This is probably the best we can do for the histogram.  We don't want to run the automation
-  // to get all the values and use them to update the histogram.
+  // This is probably the best we can do for the histogram.  We don't want to
+  // run the automation to get all the values and use them to update the
+  // histogram.
   handler().updateHistograms(value);
 
   return this;
 }
 
 AudioParam* AudioParam::setTargetAtTime(float target,
                                         double time,
                                         double timeConstant,
                                         ExceptionState& exceptionState) {
   warnIfOutsideRange("setTargetAtTime value", target);
   handler().timeline().setTargetAtTime(target, time, timeConstant,
                                        exceptionState);
 
-  // Don't update the histogram here.  It's not clear in normal usage if the parameter value will
-  // actually reach |target|.
+  // Don't update the histogram here.  It's not clear in normal usage if the
+  // parameter value will actually reach |target|.
   return this;
 }
 
 AudioParam* AudioParam::setValueCurveAtTime(DOMFloat32Array* curve,
                                             double time,
                                             double duration,
                                             ExceptionState& exceptionState) {
   float* curveData = curve->data();
   float min = minValue();
   float max = maxValue();
@@ skipping 20 matching lines @@
 
     if (value < min || value > max) {
       warnIfOutsideRange("setValueCurveAtTime value", value);
       break;
     }
   }
 
   handler().timeline().setValueCurveAtTime(curve, time, duration,
                                            exceptionState);
 
-  // We could update the histogram with every value in the curve, due to interpolation, we'll
-  // probably be missing many values.  So we don't update the histogram.  setValueCurveAtTime is
-  // probably a fairly rare method anyway.
+  // We could update the histogram with every value in the curve, due to
+  // interpolation, we'll probably be missing many values.  So we don't update
+  // the histogram.  setValueCurveAtTime is probably a fairly rare method
+  // anyway.
   return this;
 }
 
 AudioParam* AudioParam::cancelScheduledValues(double startTime,
                                               ExceptionState& exceptionState) {
   handler().timeline().cancelScheduledValues(startTime, exceptionState);
   return this;
 }
 
 }  // namespace blink