Update AbstractAudioContext::m_activeSourceNodes on the main thread only.

third_party/WebKit/Source/modules/webaudio/AbstractAudioContext.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 69 matching lines @@
 // and OfflineAudioContext respectively.
 
 // Constructor for rendering to the audio hardware.
 AbstractAudioContext::AbstractAudioContext(Document* document)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(document)
     , m_destinationNode(nullptr)
     , m_isCleared(false)
     , m_isResolvingResumePromises(false)
     , m_connectionCount(0)
-    , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_contextState(Suspended)
     , m_closedContextSampleRate(-1)
     , m_periodicWaveSine(nullptr)
     , m_periodicWaveSquare(nullptr)
     , m_periodicWaveSawtooth(nullptr)
     , m_periodicWaveTriangle(nullptr)
 {
-    m_didInitializeContextGraphMutex = true;
     m_destinationNode = DefaultAudioDestinationNode::create(this);
 
     initialize();
 }
 
 // Constructor for offline (non-realtime) rendering.
 AbstractAudioContext::AbstractAudioContext(Document* document, unsigned numberOfChannels, size_t numberOfFrames, float sampleRate)
     : ActiveScriptWrappable(this)
     , ActiveDOMObject(document)
     , m_destinationNode(nullptr)
     , m_isCleared(false)
     , m_isResolvingResumePromises(false)
     , m_connectionCount(0)
-    , m_didInitializeContextGraphMutex(false)
     , m_deferredTaskHandler(DeferredTaskHandler::create())
     , m_contextState(Suspended)
     , m_closedContextSampleRate(-1)
     , m_periodicWaveSine(nullptr)
     , m_periodicWaveSquare(nullptr)
     , m_periodicWaveSawtooth(nullptr)
     , m_periodicWaveTriangle(nullptr)
 {
-    m_didInitializeContextGraphMutex = true;
 }
 
 AbstractAudioContext::~AbstractAudioContext()
 {
     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.
     ASSERT(!isDestinationInitialized());
     ASSERT(!m_activeSourceNodes.size());
     ASSERT(!m_finishedSourceHandlers.size());
     ASSERT(!m_isResolvingResumePromises);
     ASSERT(!m_resumeResolvers.size());
 }
 
 void AbstractAudioContext::initialize()
 {
     if (isDestinationInitialized())
         return;
 
     FFTFrame::initialize();
     m_listener = AudioListener::create();
 
-    if (m_destinationNode.get()) {
+    if (m_destinationNode) {
         m_destinationNode->handler().initialize();
     }
 }
 
 void AbstractAudioContext::clear()
 {
     m_destinationNode.clear();
     // The audio rendering thread is dead.  Nobody will schedule AudioHandler
     // deletion.  Let's do it ourselves.
     deferredTaskHandler().clearHandlersToBeDeleted();
@@ skipping 33 matching lines @@
 {
     // There's no pending activity if the audio context has been cleared.
     return !m_isCleared;
 }
 
 AudioDestinationNode* AbstractAudioContext::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.
     ASSERT(!isAudioThread());
-    return m_destinationNode.get();
+    return m_destinationNode;
 }
 
 void AbstractAudioContext::throwExceptionForClosedState(ExceptionState& exceptionState)
 {
     exceptionState.throwDOMException(InvalidStateError, "AudioContext has been closed.");
 }
 
 AudioBuffer* AbstractAudioContext::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
@@ skipping 555 matching lines @@
 {
     dispatchEvent(Event::create(EventTypeNames::statechange));
 }
 
 void AbstractAudioContext::notifySourceNodeFinishedProcessing(AudioHandler* handler)
 {
     ASSERT(isAudioThread());
     m_finishedSourceHandlers.append(handler);
 }
 
+void AbstractAudioContext::removeFinishedSourceNodes()
+{
+    ASSERT(isMainThread());
+    AutoLocker locker(this);
+    // Quadratic worst case, but sizes of both vectors are considered
+    // manageable, especially |m_finishedSourceNodes| is likely to be short.
+    for (AudioNode* node : m_finishedSourceNodes) {
+        size_t i = m_activeSourceNodes.find(node);
+        if (i != kNotFound)
+            m_activeSourceNodes.remove(i);
+    }
+    m_finishedSourceNodes.clear();
+}
+
 void AbstractAudioContext::releaseFinishedSourceNodes()
 {
     ASSERT(isGraphOwner());
     ASSERT(isAudioThread());
+    bool didRemove = false;
     for (AudioHandler* handler : m_finishedSourceHandlers) {
         for (unsigned i = 0; i < m_activeSourceNodes.size(); ++i) {
             if (handler == &m_activeSourceNodes[i]->handler()) {
                 handler->breakConnection();
-                m_activeSourceNodes.remove(i);
+                m_finishedSourceNodes.append(m_activeSourceNodes[i]);
+                didRemove = true;
                 break;
             }
         }
     }
+    if (didRemove)
+        Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&AbstractAudioContext::removeFinishedSourceNodes, this));
 
     m_finishedSourceHandlers.clear();
 }
 
 void AbstractAudioContext::notifySourceNodeStartedProcessing(AudioNode* node)
 {
     ASSERT(isMainThread());
     AutoLocker locker(this);
 
     m_activeSourceNodes.append(node);
@@ skipping 136 matching lines @@
     if (m_contextState == Suspended) {
         destination()->audioDestinationHandler().startRendering();
         setContextState(Running);
     }
 }
 
 DEFINE_TRACE(AbstractAudioContext)
 {
     visitor->trace(m_destinationNode);
     visitor->trace(m_listener);
-    // trace() can be called in AbstractAudioContext constructor, and
-    // m_contextGraphMutex might be unavailable.
-    if (m_didInitializeContextGraphMutex) {
-        AutoLocker lock(this);
-        visitor->trace(m_activeSourceNodes);
-    } else {
-        visitor->trace(m_activeSourceNodes);
-    }
+    visitor->trace(m_activeSourceNodes);
     visitor->trace(m_resumeResolvers);
     visitor->trace(m_decodeAudioResolvers);
 
     visitor->trace(m_periodicWaveSine);
     visitor->trace(m_periodicWaveSquare);
     visitor->trace(m_periodicWaveSawtooth);
     visitor->trace(m_periodicWaveTriangle);
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 SecurityOrigin* AbstractAudioContext::getSecurityOrigin() const
 {
     if (getExecutionContext())
         return getExecutionContext()->getSecurityOrigin();
 
     return nullptr;
 }
 
 } // namespace blink