Hold global GC heap lock while making audio thread access.

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 155 matching lines @@
   if (!is_render_bus_allocated)
     return;
 
   // Start rendering.
   DoOfflineRendering();
 }
 
 void OfflineAudioDestinationHandler::DoOfflineRendering() {
   DCHECK(!IsMainThread());
 
-  unsigned number_of_channels = render_target_->numberOfChannels();
+  unsigned number_of_channels;
+  Vector<float*> destinations;
+  {
+    // Main thread GCs cannot happen while we're reading out channel
+    // data. Detect that condition by trying to take the cross-thread
+    // persistent lock which is held while a GC runs. If the lock is
+    // already held, simply delay rendering until the next quantum.
+    CrossThreadPersistentRegion::LockScope gc_lock(
+        ProcessHeap::GetCrossThreadPersistentRegion(), true);
+    if (!gc_lock.HasLock())
+      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_)
       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();
-      float* destination =
-          render_target_->getChannelData(channel_index).View()->Data();
-      memcpy(destination + frames_processed_, source,
+      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.
@@ skipping 130 matching lines @@
   SetHandler(OfflineAudioDestinationHandler::Create(*this, render_target));
 }
 
 OfflineAudioDestinationNode* OfflineAudioDestinationNode::Create(
     BaseAudioContext* context,
     AudioBuffer* render_target) {
   return new OfflineAudioDestinationNode(*context, render_target);
 }
 
 }  // namespace blink