reflow comments in modules/{webaudio,vr}

third_party/WebKit/Source/modules/webaudio/BaseAudioContext.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 119 matching lines @@
       m_deferredTaskHandler(DeferredTaskHandler::create()),
       m_contextState(Suspended),
       m_closedContextSampleRate(-1),
       m_periodicWaveSine(nullptr),
       m_periodicWaveSquare(nullptr),
       m_periodicWaveSawtooth(nullptr),
       m_periodicWaveTriangle(nullptr) {}
 
 BaseAudioContext::~BaseAudioContext() {
   deferredTaskHandler().contextWillBeDestroyed();
-  // AudioNodes keep a reference to their context, so there should be no way to be in the destructor if there are still AudioNodes around.
+  // AudioNodes keep a reference to their context, so there should be no way to
+  // be in the destructor if there are still AudioNodes around.
   DCHECK(!isDestinationInitialized());
   DCHECK(!m_activeSourceNodes.size());
   DCHECK(!m_finishedSourceHandlers.size());
   DCHECK(!m_isResolvingResumePromises);
   DCHECK(!m_resumeResolvers.size());
 }
 
 void BaseAudioContext::initialize() {
   if (isDestinationInitialized())
     return;
 
   FFTFrame::initialize();
 
   if (m_destinationNode) {
     m_destinationNode->handler().initialize();
-    // The AudioParams in the listener need access to the destination node, so only create the
-    // listener if the destination node exists.
+    // The AudioParams in the listener need access to the destination node, so
+    // only create the listener if the destination node exists.
     m_listener = AudioListener::create(*this);
   }
 }
 
 void BaseAudioContext::clear() {
   m_destinationNode.clear();
   // The audio rendering thread is dead.  Nobody will schedule AudioHandler
   // deletion.  Let's do it ourselves.
   deferredTaskHandler().clearHandlersToBeDeleted();
   m_isCleared = true;
@@ skipping 25 matching lines @@
 void BaseAudioContext::stop() {
   uninitialize();
 }
 
 bool BaseAudioContext::hasPendingActivity() const {
   // There's no pending activity if the audio context has been cleared.
   return !m_isCleared;
 }
 
 AudioDestinationNode* BaseAudioContext::destination() const {
-  // Cannot be called from the audio thread because this method touches objects managed by Oilpan,
-  // and the audio thread is not managed by Oilpan.
+  // Cannot be called from the audio thread because this method touches objects
+  // managed by Oilpan, and the audio thread is not managed by Oilpan.
   DCHECK(!isAudioThread());
   return m_destinationNode;
 }
 
 void BaseAudioContext::throwExceptionForClosedState(
     ExceptionState& exceptionState) {
   exceptionState.throwDOMException(InvalidStateError,
                                    "AudioContext has been closed.");
 }
 
 AudioBuffer* BaseAudioContext::createBuffer(unsigned numberOfChannels,
                                             size_t numberOfFrames,
                                             float sampleRate,
                                             ExceptionState& exceptionState) {
-  // It's ok to call createBuffer, even if the context is closed because the AudioBuffer doesn't
-  // really "belong" to any particular context.
+  // It's ok to call createBuffer, even if the context is closed because the
+  // AudioBuffer doesn't really "belong" to any particular context.
 
   AudioBuffer* buffer = AudioBuffer::create(numberOfChannels, numberOfFrames,
                                             sampleRate, exceptionState);
 
   if (buffer) {
     // Only record the data if the creation succeeded.
     DEFINE_STATIC_LOCAL(SparseHistogram, audioBufferChannelsHistogram,
                         ("WebAudio.AudioBuffer.NumberOfChannels"));
 
     // Arbitrarly limit the maximum length to 1 million frames (about 20 sec
@@ skipping 82 matching lines @@
   m_decodeAudioResolvers.remove(resolver);
 }
 
 AudioBufferSourceNode* BaseAudioContext::createBufferSource(
     ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
   AudioBufferSourceNode* node =
       AudioBufferSourceNode::create(*this, exceptionState);
 
-  // Do not add a reference to this source node now. The reference will be added when start() is
-  // called.
+  // Do not add a reference to this source node now. The reference will be added
+  // when start() is called.
 
   return node;
 }
 
 MediaElementAudioSourceNode* BaseAudioContext::createMediaElementSource(
     HTMLMediaElement* mediaElement,
     ExceptionState& exceptionState) {
   DCHECK(isMainThread());
 
   return MediaElementAudioSourceNode::create(*this, *mediaElement,
@@ skipping 211 matching lines @@
       if (!m_periodicWaveTriangle)
         m_periodicWaveTriangle = PeriodicWave::createTriangle(sampleRate());
       return m_periodicWaveTriangle;
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 String BaseAudioContext::state() const {
-  // These strings had better match the strings for AudioContextState in AudioContext.idl.
+  // These strings had better match the strings for AudioContextState in
+  // AudioContext.idl.
   switch (m_contextState) {
     case Suspended:
       return "suspended";
     case Running:
       return "running";
     case Closed:
       return "closed";
   }
   NOTREACHED();
   return "";
 }
 
 void BaseAudioContext::setContextState(AudioContextState newState) {
   DCHECK(isMainThread());
 
-  // Validate the transitions.  The valid transitions are Suspended->Running, Running->Suspended,
-  // and anything->Closed.
+  // Validate the transitions.  The valid transitions are Suspended->Running,
+  // Running->Suspended, and anything->Closed.
   switch (newState) {
     case Suspended:
       DCHECK_EQ(m_contextState, Running);
       break;
     case Running:
       DCHECK_EQ(m_contextState, Suspended);
       break;
     case Closed:
       DCHECK_NE(m_contextState, Closed);
       break;
@@ skipping 94 matching lines @@
       AudioBufferSourceNode* sourceNode =
           static_cast<AudioBufferSourceNode*>(node);
       sourceNode->audioBufferSourceHandler().handleStoppableSourceNode();
     }
   }
 }
 
 void BaseAudioContext::handlePreRenderTasks() {
   DCHECK(isAudioThread());
 
-  // At the beginning of every render quantum, try to update the internal rendering graph state (from main thread changes).
-  // It's OK if the tryLock() fails, we'll just take slightly longer to pick up the changes.
+  // At the beginning of every render quantum, try to update the internal
+  // rendering graph state (from main thread changes).  It's OK if the tryLock()
+  // fails, we'll just take slightly longer to pick up the changes.
   if (tryLock()) {
     deferredTaskHandler().handleDeferredTasks();
 
     resolvePromisesForResume();
 
-    // Check to see if source nodes can be stopped because the end time has passed.
+    // Check to see if source nodes can be stopped because the end time has
+    // passed.
     handleStoppableSourceNodes();
 
     // Update the dirty state of the listener.
     listener()->updateState();
 
     unlock();
   }
 }
 
 void BaseAudioContext::handlePostRenderTasks() {
   DCHECK(isAudioThread());
 
-  // Must use a tryLock() here too.  Don't worry, the lock will very rarely be contended and this method is called frequently.
-  // The worst that can happen is that there will be some nodes which will take slightly longer than usual to be deleted or removed
-  // from the render graph (in which case they'll render silence).
+  // Must use a tryLock() here too.  Don't worry, the lock will very rarely be
+  // contended and this method is called frequently.  The worst that can happen
+  // is that there will be some nodes which will take slightly longer than usual
+  // to be deleted or removed from the render graph (in which case they'll
+  // render silence).
   if (tryLock()) {
     // Take care of AudioNode tasks where the tryLock() failed previously.
     deferredTaskHandler().breakConnections();
 
     // Dynamically clean up nodes which are no longer needed.
     releaseFinishedSourceNodes();
 
     deferredTaskHandler().handleDeferredTasks();
     deferredTaskHandler().requestToDeleteHandlersOnMainThread();
 
@@ skipping 12 matching lines @@
     } else {
       resolver->resolve();
     }
   }
 
   m_resumeResolvers.clear();
   m_isResolvingResumePromises = false;
 }
 
 void BaseAudioContext::resolvePromisesForResume() {
-  // This runs inside the BaseAudioContext's lock when handling pre-render tasks.
+  // This runs inside the BaseAudioContext's lock when handling pre-render
+  // tasks.
   DCHECK(isAudioThread());
   ASSERT(isGraphOwner());
 
-  // Resolve any pending promises created by resume(). Only do this if we haven't already started
-  // resolving these promises. This gets called very often and it takes some time to resolve the
-  // promises in the main thread.
+  // Resolve any pending promises created by resume(). Only do this if we
+  // haven't already started resolving these promises. This gets called very
+  // often and it takes some time to resolve the promises in the main thread.
   if (!m_isResolvingResumePromises && m_resumeResolvers.size() > 0) {
     m_isResolvingResumePromises = true;
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&BaseAudioContext::resolvePromisesForResumeOnMainThread,
                         wrapCrossThreadPersistent(this)));
   }
 }
 
 void BaseAudioContext::rejectPendingDecodeAudioDataResolvers() {
@@ skipping 20 matching lines @@
       ->addConsoleMessage(ConsoleMessage::create(
           JSMessageSource, WarningMessageLevel,
           "An AudioContext in a cross origin iframe must be created or resumed "
           "from a user gesture to enable audio output."));
   return false;
 }
 
 void BaseAudioContext::rejectPendingResolvers() {
   DCHECK(isMainThread());
 
-  // Audio context is closing down so reject any resume promises that are still pending.
+  // Audio context is closing down so reject any resume promises that are still
+  // pending.
 
   for (auto& resolver : m_resumeResolvers) {
     resolver->reject(
         DOMException::create(InvalidStateError, "Audio context is going away"));
   }
   m_resumeResolvers.clear();
   m_isResolvingResumePromises = false;
 
   rejectPendingDecodeAudioDataResolvers();
 }
@@ skipping 34 matching lines @@
 }
 
 SecurityOrigin* BaseAudioContext::getSecurityOrigin() const {
   if (getExecutionContext())
     return getExecutionContext()->getSecurityOrigin();
 
   return nullptr;
 }
 
 }  // namespace blink