Simplify OfflineAudioDestinationNode::DoOfflineRendering().

third_party/WebKit/Source/modules/webaudio/OfflineAudioDestinationNode.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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 30 matching lines @@
 
 namespace blink {
 
 OfflineAudioDestinationHandler::OfflineAudioDestinationHandler(
     AudioNode& node,
     AudioBuffer* render_target)
     : AudioDestinationHandler(node),
       render_target_(render_target),
       frames_processed_(0),
       frames_to_process_(0),
-      is_rendering_started_(false),
-      should_suspend_(false) {
+      is_rendering_started_(false) {
   render_bus_ = AudioBus::Create(render_target->numberOfChannels(),
                                  AudioUtilities::kRenderQuantumFrames);
   frames_to_process_ = render_target_->length();
 
   // Node-specific defaults.
   channel_count_ = render_target_->numberOfChannels();
   SetInternalChannelCountMode(kExplicit);
   SetInternalChannelInterpretation(AudioBus::kSpeakers);
 }
 
@@ skipping 127 matching lines @@
                WrapPassRefPtr(this)));
       return;
     }
 
     number_of_channels = render_target_->numberOfChannels();
     destinations.ReserveInitialCapacity(number_of_channels);
     for (unsigned i = 0; i < number_of_channels; ++i)
       destinations.push_back(render_target_->getChannelData(i).View()->Data());
   }
 
-  // Reset the suspend flag.
-  should_suspend_ = false;
-
   // If there is more to process and there is no suspension at the moment,
   // do continue to render quanta. Then calling OfflineAudioContext.resume()
   // will pick up the render loop again from where it was suspended.
-  while (frames_to_process_ > 0 && !should_suspend_) {
-    // Suspend the rendering and update m_shouldSuspend if a scheduled
-    // suspend found at the current sample frame. Otherwise render one
-    // quantum and return false.
-    should_suspend_ = RenderIfNotSuspended(
-        0, render_bus_.Get(), AudioUtilities::kRenderQuantumFrames);
-
-    if (should_suspend_)
+  while (frames_to_process_ > 0) {
+    // Suspend the rendering if a scheduled suspend found at the current
+    // sample frame. Otherwise render one quantum.
+    if (RenderIfNotSuspended(0, render_bus_.Get(),
+                             AudioUtilities::kRenderQuantumFrames))
       return;
 
     size_t frames_available_to_copy =
         std::min(frames_to_process_,
                  static_cast<size_t>(AudioUtilities::kRenderQuantumFrames));
 
     for (unsigned channel_index = 0; channel_index < number_of_channels;
          ++channel_index) {
       const float* source = render_bus_->Channel(channel_index)->Data();
       memcpy(destinations[channel_index] + frames_processed_, source,
              sizeof(float) * frames_available_to_copy);
     }
 
     frames_processed_ += frames_available_to_copy;
 
     DCHECK_GE(frames_to_process_, frames_available_to_copy);
     frames_to_process_ -= frames_available_to_copy;
   }
 
-  // Finish up the rendering loop if there is no more to process.
-  if (!frames_to_process_)
-    FinishOfflineRendering();
+  DCHECK_EQ(frames_to_process_, 0u);
+  FinishOfflineRendering();
 }
 
 void OfflineAudioDestinationHandler::SuspendOfflineRendering() {
   DCHECK(!IsMainThread());
 
   // The actual rendering has been suspended. Notify the context.
   if (Context()->GetExecutionContext()) {
     TaskRunnerHelper::Get(TaskType::kMediaElementEvent,
                           Context()->GetExecutionContext())
         ->PostTask(BLINK_FROM_HERE,
@@ skipping 118 matching lines @@
   SetHandler(OfflineAudioDestinationHandler::Create(*this, render_target));
 }
 
 OfflineAudioDestinationNode* OfflineAudioDestinationNode::Create(
     BaseAudioContext* context,
     AudioBuffer* render_target) {
   return new OfflineAudioDestinationNode(*context, render_target);
 }
 
 }  // namespace blink