Keep AudioScheduledSourceNode alive until onended is called.

Source/modules/webaudio/AudioScheduledSourceNode.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 24 matching lines @@
 #include "wtf/MathExtras.h"
 
 using namespace std;
 
 namespace WebCore {
 
 const double AudioScheduledSourceNode::UnknownTime = -1;
 
 AudioScheduledSourceNode::AudioScheduledSourceNode(AudioContext* context, float sampleRate)
     : AudioSourceNode(context, sampleRate)
+    , ActiveDOMObject(context->scriptExecutionContext())
     , m_playbackState(UNSCHEDULED_STATE)
     , m_startTime(0)
     , m_endTime(UnknownTime)
     , m_hasEndedListener(false)
 {
 }
 
 void AudioScheduledSourceNode::updateSchedulingInfo(size_t quantumFrameSize,
                                                     AudioBus* outputBus,
                                                     size_t& quantumFrameOffset,
@@ skipping 82 matching lines @@
 void AudioScheduledSourceNode::start(double when)
 {
     ASSERT(isMainThread());
     if (m_playbackState != UNSCHEDULED_STATE)
         return;
 
     m_startTime = when;
     m_playbackState = SCHEDULED_STATE;
 }
 
-void AudioScheduledSourceNode::stop(double when)
+void AudioScheduledSourceNode::stopNote(double when)
 {
     ASSERT(isMainThread());
     if (!(m_playbackState == SCHEDULED_STATE || m_playbackState == PLAYING_STATE))
         return;
 
     when = max(0.0, when);
     m_endTime = when;
 }
 
 void AudioScheduledSourceNode::noteOn(double when)
 {
     start(when);
 }
 
 void AudioScheduledSourceNode::noteOff(double when)
 {
-    stop(when);
+    stopNote(when);
 }
 
 void AudioScheduledSourceNode::setOnended(PassRefPtr<EventListener> listener, DOMWrapperWorld* isolatedWorld)
 {
     m_hasEndedListener = listener;
     setAttributeEventListener(eventNames().endedEvent, listener, isolatedWorld);
 }
 
 void AudioScheduledSourceNode::finish()
 {
     if (m_playbackState != FINISHED_STATE) {
         // Let the context dereference this AudioNode.
         context()->notifyNodeFinishedProcessing(this);
         m_playbackState = FINISHED_STATE;
         context()->decrementActiveSourceCount();
     }
 
-    if (m_hasEndedListener)
+    if (m_hasEndedListener) {
+        setPendingActivity(this);

[Ken Russell (switch to Gerrit), 2013/09/09 21:30:05]

Sorry, I failed to realize this before. This can't be called here -- this code
runs on the audio thread, and ActiveDOMObject, Node, EventTarget, etc., aren't
thread-safe.

I think that we'll have to figure out some other solution. Perhaps the node
can't transition to the FINISHED state until the onended callback has been
called on the main thread.

[Ken Russell (switch to Gerrit), 2013/09/09 21:34:31]

Apologies, I think I'm wrong. AudioNode::ref is specifically thread-safe. Let's
follow up offline.

         callOnMainThread(&AudioScheduledSourceNode::notifyEndedDispatch, this);
+    }
 }
 
 void AudioScheduledSourceNode::notifyEndedDispatch(void* userData)
 {
     static_cast<AudioScheduledSourceNode*>(userData)->notifyEnded();
 }
 
 void AudioScheduledSourceNode::notifyEnded()
 {
-    RefPtr<Event> event = Event::create(eventNames().endedEvent);
-    event->setTarget(this);
-    dispatchEvent(event.get());
+    // Avoid firing the event if the document has already gone away.
+    if (context()->scriptExecutionContext()) {
+        RefPtr<Event> event = Event::create(eventNames().endedEvent);
+        event->setTarget(this);
+        dispatchEvent(event.get());
+    }
+    unsetPendingActivity(this);

[Ken Russell (switch to Gerrit), 2013/09/09 19:45:47]

This looks wrong now. What happens if we navigate away from the document, stop()
is called first, and the audio processing thread afterward finishes handling the
node and notifyEnded() is called on the main thread? As far as I can see both
unsetPendingActivity calls should be conditional. I don't know the conditions
under which notifyEnded will be called but please explain why this code is
correct.

+}
+
+ScriptExecutionContext* AudioScheduledSourceNode::scriptExecutionContext() const
+{
+    return context()->scriptExecutionContext();
+}
+
+void AudioScheduledSourceNode::stop()
+{
+    if (hasPendingActivity())
+        unsetPendingActivity(this);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)