DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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

 /*
  * Copyright (C) 2011 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 43 matching lines @@
 // value (1.1754944e-38) because we normally operate with flush-to-zero enabled.
 const float kSetTargetZeroThreshold = 1e-20;
 
 static bool isNonNegativeAudioParamTime(double time,
                                         ExceptionState& exceptionState,
                                         String message = "Time") {
   if (time >= 0)
     return true;
 
   exceptionState.throwDOMException(
-      InvalidAccessError, message + " must be a finite non-negative number: " +
-                              String::number(time));
+      InvalidAccessError,
+      message +
+          " must be a finite non-negative number: " + String::number(time));
   return false;
 }
 
 static bool isPositiveAudioParamTime(double time,
                                      ExceptionState& exceptionState,
                                      String message) {
   if (time > 0)
     return true;
 
   exceptionState.throwDOMException(
@@ skipping 412 matching lines @@
                                              ExceptionState& exceptionState) {
   DCHECK(isMainThread());
   DCHECK(curve);
 
   if (!isNonNegativeAudioParamTime(time, exceptionState) ||
       !isPositiveAudioParamTime(duration, exceptionState, "Duration"))
     return;
 
   if (curve->length() < 2) {
     exceptionState.throwDOMException(
-        InvalidStateError, ExceptionMessages::indexExceedsMinimumBound(
-                               "curve length", curve->length(), 2U));
+        InvalidStateError,
+        ExceptionMessages::indexExceedsMinimumBound("curve length",
+                                                    curve->length(), 2U));
     return;
   }
 
   MutexLocker locker(m_eventsLock);
   insertEvent(ParamEvent::createSetValueCurveEvent(curve, time, duration),
               exceptionState);
 
   // Insert a setValueAtTime event too to establish an event so that all
   // following events will process from the end of the curve instead of the
   // beginning.
@@ skipping 19 matching lines @@
     return;
 
   unsigned i = 0;
   double insertTime = event->time();
 
   if (!m_events.size() &&
       (event->getType() == ParamEvent::LinearRampToValue ||
        event->getType() == ParamEvent::ExponentialRampToValue)) {
     // There are no events preceding these ramps.  Insert a new setValueAtTime
     // event to set the starting point for these events.
-    m_events.insert(0, AudioParamTimeline::ParamEvent::createSetValueEvent(
-                           event->initialValue(), event->callTime()));
+    m_events.insert(0,
+                    AudioParamTimeline::ParamEvent::createSetValueEvent(
+                        event->initialValue(), event->callTime()));
   }
 
   for (i = 0; i < m_events.size(); ++i) {
     if (event->getType() == ParamEvent::SetValueCurve) {
       // If this event is a SetValueCurve, make sure it doesn't overlap any
       // existing event. It's ok if the SetValueCurve starts at the same time as
       // the end of some other duration.
       double endTime = event->time() + event->duration();
       if (m_events[i]->time() > event->time() &&
           m_events[i]->time() < endTime) {
         exceptionState.throwDOMException(
             NotSupportedError,
             eventToString(*event) + " overlaps " + eventToString(*m_events[i]));
         return;
       }
     } else {
       // Otherwise, make sure this event doesn't overlap any existing
       // SetValueCurve event.
       if (m_events[i]->getType() == ParamEvent::SetValueCurve) {
         double endTime = m_events[i]->time() + m_events[i]->duration();
         if (event->time() >= m_events[i]->time() && event->time() < endTime) {
-          exceptionState.throwDOMException(
-              NotSupportedError, eventToString(*event) + " overlaps " +
-                                     eventToString(*m_events[i]));
+          exceptionState.throwDOMException(NotSupportedError,
+                                           eventToString(*event) +
+                                               " overlaps " +
+                                               eventToString(*m_events[i]));
           return;
         }
       }
     }
 
     // Overwrite same event type and time.
     if (m_events[i]->time() == insertTime &&
         m_events[i]->getType() == event->getType()) {
       m_events[i] = std::move(event);
       return;
@@ skipping 59 matching lines @@
       break;
     }
   }
 
   // The event that is being cancelled.  This is the event just past
   // cancelTime, if any.
   unsigned cancelledEventIndex = i;
 
   // If the event just before cancelTime is a SetTarget or SetValueCurve
   // event, we need to handle that event specially instead of the event after.
-  if (i > 0 && ((m_events[i - 1]->getType() == ParamEvent::SetTarget) ||
-                (m_events[i - 1]->getType() == ParamEvent::SetValueCurve))) {
+  if (i > 0 &&
+      ((m_events[i - 1]->getType() == ParamEvent::SetTarget) ||
+       (m_events[i - 1]->getType() == ParamEvent::SetValueCurve))) {
     cancelledEventIndex = i - 1;
   } else if (i >= m_events.size()) {
     // If there were no events occurring after |cancelTime| (and the
     // previous event is not SetTarget or SetValueCurve, we're done.
     return;
   }
 
   // cancelledEvent is the event that is being cancelled.
   ParamEvent* cancelledEvent = m_events[cancelledEventIndex].get();
   ParamEvent::Type eventType = cancelledEvent->getType();
@@ skipping 718 matching lines @@
     //
     //   v((c+k)/F) = V*m^k
     //
     // where
     //   V = v1*(v2/v1)^((c/F-t1)/(t2-t1))
     //   m = (v2/v1)^(1/(F*(t2-t1)))
 
     // Compute the per-sample multiplier.
     float multiplier = powf(value2 / value1, 1 / numSampleFrames);
     // Set the starting value of the exponential ramp.
-    value = value1 * powf(value2 / value1,
-                          (currentFrame / sampleRate - time1) / deltaTime);
+    value =
+        value1 *
+        powf(value2 / value1, (currentFrame / sampleRate - time1) / deltaTime);
 
     for (; writeIndex < fillToFrame; ++writeIndex) {
       values[writeIndex] = value;
       value *= multiplier;
       ++currentFrame;
     }
     // |value| got updated one extra time in the above loop.  Restore it to
     // the last computed value.
     if (writeIndex >= 1)
       value /= multiplier;
@@ skipping 348 matching lines @@
                                              unsigned writeIndex) {
   size_t index = writeIndex;
 
   for (; index < endFrame; ++index)
     values[index] = defaultValue;
 
   return index;
 }
 
 }  // namespace blink