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

third_party/WebKit/Source/modules/webaudio/OfflineAudioContext.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 48 matching lines @@
   Document* document = toDocument(context);
 
   if (!numberOfFrames) {
     exceptionState.throwDOMException(SyntaxError,
                                      "number of frames cannot be zero.");
     return nullptr;
   }
 
   if (numberOfChannels > BaseAudioContext::maxNumberOfChannels()) {
     exceptionState.throwDOMException(
-        IndexSizeError, ExceptionMessages::indexOutsideRange<unsigned>(
-                            "number of channels", numberOfChannels, 0,
-                            ExceptionMessages::InclusiveBound,
-                            BaseAudioContext::maxNumberOfChannels(),
-                            ExceptionMessages::InclusiveBound));
+        IndexSizeError,
+        ExceptionMessages::indexOutsideRange<unsigned>(
+            "number of channels", numberOfChannels, 0,
+            ExceptionMessages::InclusiveBound,
+            BaseAudioContext::maxNumberOfChannels(),
+            ExceptionMessages::InclusiveBound));
     return nullptr;
   }
 
   if (!AudioUtilities::isValidAudioBufferSampleRate(sampleRate)) {
     exceptionState.throwDOMException(
-        IndexSizeError, ExceptionMessages::indexOutsideRange(
-                            "sampleRate", sampleRate,
-                            AudioUtilities::minAudioBufferSampleRate(),
-                            ExceptionMessages::InclusiveBound,
-                            AudioUtilities::maxAudioBufferSampleRate(),
-                            ExceptionMessages::InclusiveBound));
+        IndexSizeError,
+        ExceptionMessages::indexOutsideRange(
+            "sampleRate", sampleRate,
+            AudioUtilities::minAudioBufferSampleRate(),
+            ExceptionMessages::InclusiveBound,
+            AudioUtilities::maxAudioBufferSampleRate(),
+            ExceptionMessages::InclusiveBound));
     return nullptr;
   }
 
   OfflineAudioContext* audioContext = new OfflineAudioContext(
       document, numberOfChannels, numberOfFrames, sampleRate, exceptionState);
 
   if (!audioContext->destination()) {
     exceptionState.throwDOMException(
-        NotSupportedError, "OfflineAudioContext(" +
-                               String::number(numberOfChannels) + ", " +
-                               String::number(numberOfFrames) + ", " +
-                               String::number(sampleRate) + ")");
+        NotSupportedError,
+        "OfflineAudioContext(" + String::number(numberOfChannels) + ", " +
+            String::number(numberOfFrames) + ", " + String::number(sampleRate) +
+            ")");
   }
 
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: OfflineAudioContext::OfflineAudioContext()\n",
           audioContext);
 #endif
   DEFINE_STATIC_LOCAL(SparseHistogram, offlineContextChannelCountHistogram,
                       ("WebAudio.OfflineAudioContext.ChannelCount"));
   // Arbitrarly limit the maximum length to 1 million frames (about 20 sec
   // at 48kHz).  The number of buckets is fairly arbitrary.
@@ skipping 28 matching lines @@
   m_renderTarget =
       AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate);
 
   // Throw an exception if the render target is not ready.
   if (m_renderTarget) {
     m_destinationNode =
         OfflineAudioDestinationNode::create(this, m_renderTarget.get());
     initialize();
   } else {
     exceptionState.throwRangeError(ExceptionMessages::failedToConstruct(
-        "OfflineAudioContext", "failed to create OfflineAudioContext(" +
-                                   String::number(numberOfChannels) + ", " +
-                                   String::number(numberOfFrames) + ", " +
-                                   String::number(sampleRate) + ")"));
+        "OfflineAudioContext",
+        "failed to create OfflineAudioContext(" +
+            String::number(numberOfChannels) + ", " +
+            String::number(numberOfFrames) + ", " + String::number(sampleRate) +
+            ")"));
   }
 }
 
 OfflineAudioContext::~OfflineAudioContext() {
 #if DEBUG_AUDIONODE_REFERENCES
   fprintf(stderr, "[%16p]: OfflineAudioContext::~OfflineAudioContext()\n",
           this);
 #endif
 }
 
@@ skipping 82 matching lines @@
   size_t frame = when * sampleRate();
   frame -= frame % destinationHandler().renderQuantumFrames();
 
   // The suspend time should be earlier than the total render frame. If the
   // requested suspension time is equal to the total render frame, the promise
   // will be rejected.
   if (m_totalRenderFrames <= frame) {
     resolver->reject(DOMException::create(
         InvalidStateError,
         "cannot schedule a suspend at frame " + String::number(frame) + " (" +
-            String::number(when) + " seconds) " + "because it is greater than "
-                                                  "or equal to the total "
-                                                  "render duration of " +
+            String::number(when) + " seconds) " +
+            "because it is greater than "
+            "or equal to the total "
+            "render duration of " +
             String::number(m_totalRenderFrames) + " frames"));
     return promise;
   }
 
   // The specified suspend time is in the past; reject the promise.
   if (frame < currentSampleFrame()) {
     size_t currentFrameClamped = std::min(currentSampleFrame(), length());
     double currentTimeClamped =
         std::min(currentTime(), length() / static_cast<double>(sampleRate()));
     resolver->reject(DOMException::create(
         InvalidStateError,
         "suspend(" + String::number(when) + ") failed to suspend at frame " +
             String::number(frame) + " because it is earlier than the current " +
             "frame of " + String::number(currentFrameClamped) + " (" +
             String::number(currentTimeClamped) + " seconds)"));
     return promise;
   }
 
   // Wait until the suspend map is available for the insertion. Here we should
   // use AutoLocker because it locks the graph from the main thread.
   AutoLocker locker(this);
 
   // If there is a duplicate suspension at the same quantized frame,
   // reject the promise.
   if (m_scheduledSuspends.contains(frame)) {
     resolver->reject(DOMException::create(
-        InvalidStateError, "cannot schedule more than one suspend at frame " +
-                               String::number(frame) + " (" +
-                               String::number(when) + " seconds)"));
+        InvalidStateError,
+        "cannot schedule more than one suspend at frame " +
+            String::number(frame) + " (" + String::number(when) + " seconds)"));
     return promise;
   }
 
   m_scheduledSuspends.insert(frame, resolver);
 
   return promise;
 }
 
 ScriptPromise OfflineAudioContext::resumeContext(ScriptState* scriptState) {
   DCHECK(isMainThread());
@@ skipping 150 matching lines @@
 
   // Note that the GraphLock is required before this check. Since this needs
   // to run on the audio thread, OfflineGraphAutoLocker must be used.
   if (m_scheduledSuspends.contains(currentSampleFrame()))
     return true;
 
   return false;
 }
 
 }  // namespace blink