Protect AudioScheduledSoureNode::m_startTime and m_endTime.

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 23 matching lines @@
 #include "platform/audio/AudioUtilities.h"
 #include "wtf/MathExtras.h"
 #include <algorithm>
 
 namespace blink {
 
 const double AudioScheduledSourceHandler::UnknownTime = -1;
 
 AudioScheduledSourceHandler::AudioScheduledSourceHandler(NodeType nodeType, AudioNode& node, float sampleRate)
     : AudioHandler(nodeType, node, sampleRate)
+    , m_hasEndedListener(false)
     , m_startTime(0)
     , m_endTime(UnknownTime)
-    , m_hasEndedListener(false)
     , m_playbackState(UNSCHEDULED_STATE)
 {
 }
 
 void AudioScheduledSourceHandler::updateSchedulingInfo(
     size_t quantumFrameSize, AudioBus* outputBus, size_t& quantumFrameOffset, size_t& nonSilentFramesToProcess)
 {
     ASSERT(outputBus);
     if (!outputBus)
         return;
 
     ASSERT(quantumFrameSize == ProcessingSizeInFrames);
     if (quantumFrameSize != ProcessingSizeInFrames)
         return;
 
     double sampleRate = this->sampleRate();
 
     // quantumStartFrame     : Start frame of the current time quantum.
     // quantumEndFrame       : End frame of the current time quantum.
     // startFrame            : Start frame for this source.
     // endFrame              : End frame for this source.
     size_t quantumStartFrame = context()->currentSampleFrame();
     size_t quantumEndFrame = quantumStartFrame + quantumFrameSize;
-    size_t startFrame = AudioUtilities::timeToSampleFrame(m_startTime, sampleRate);
-    size_t endFrame = m_endTime == UnknownTime ? 0 : AudioUtilities::timeToSampleFrame(m_endTime, sampleRate);
+    size_t startFrame = AudioUtilities::timeToSampleFrame(startTime(), sampleRate);
+    double currentEndTime = endTime();
+    size_t endFrame = currentEndTime == UnknownTime ? 0 : AudioUtilities::timeToSampleFrame(currentEndTime, sampleRate);
 
     // If we know the end time and it's already passed, then don't bother doing any more rendering this cycle.
-    if (m_endTime != UnknownTime && endFrame <= quantumStartFrame)
+    if (currentEndTime != UnknownTime && endFrame <= quantumStartFrame)
         finish();
 
     PlaybackState state = playbackState();
 
     if (state == UNSCHEDULED_STATE || state == FINISHED_STATE || startFrame >= quantumEndFrame) {
         // Output silence.
         outputBus->zero();
         nonSilentFramesToProcess = 0;
         return;
     }
@@ skipping 17 matching lines @@
     // Handle silence before we start playing.
     // Zero any initial frames representing silence leading up to a rendering start time in the middle of the quantum.
     if (quantumFrameOffset) {
         for (unsigned i = 0; i < outputBus->numberOfChannels(); ++i)
             memset(outputBus->channel(i)->mutableData(), 0, sizeof(float) * quantumFrameOffset);
     }
 
     // Handle silence after we're done playing.
     // If the end time is somewhere in the middle of this time quantum, then zero out the
     // frames from the end time to the very end of the quantum.
-    if (m_endTime != UnknownTime && endFrame >= quantumStartFrame && endFrame < quantumEndFrame) {
+    if (currentEndTime != UnknownTime && endFrame >= quantumStartFrame && endFrame < quantumEndFrame) {
         size_t zeroStartFrame = endFrame - quantumStartFrame;
         size_t framesToZero = quantumFrameSize - zeroStartFrame;
 
         bool isSafe = zeroStartFrame < quantumFrameSize && framesToZero <= quantumFrameSize && zeroStartFrame + framesToZero <= quantumFrameSize;
         ASSERT(isSafe);
 
         if (isSafe) {
             if (framesToZero > nonSilentFramesToProcess)
                 nonSilentFramesToProcess = 0;
             else
@@ skipping 30 matching lines @@
         return;
     }
 
     // The node is started. Add a reference to keep us alive so that audio will eventually get
     // played even if Javascript should drop all references to this node. The reference will get
     // dropped when the source has finished playing.
     context()->notifySourceNodeStartedProcessing(node());
 
     // If |when| < currentTime, the source must start now according to the spec.
     // So just set startTime to currentTime in this case to start the source now.
-    m_startTime = std::max(when, context()->currentTime());
+    setStartTime(std::max(when, context()->currentTime()));
 
     setPlaybackState(SCHEDULED_STATE);
 }
 
 void AudioScheduledSourceHandler::stop(double when, ExceptionState& exceptionState)
 {
     ASSERT(isMainThread());
 
     if (playbackState() == UNSCHEDULED_STATE) {
         exceptionState.throwDOMException(
             InvalidStateError,
             "cannot call stop without calling start first.");
         return;
     }
 
     if (when < 0) {
         exceptionState.throwDOMException(
             InvalidAccessError,
             ExceptionMessages::indexExceedsMinimumBound(
                 "stop time",
                 when,
                 0.0));
         return;
     }
 
     // stop() can be called more than once, with the last call to stop taking effect, unless the
     // source has already stopped due to earlier calls to stop. No exceptions are thrown in any
     // case.
     when = std::max(0.0, when);
-    m_endTime = when;
+    setEndTime(when);
 }
 
 void AudioScheduledSourceHandler::finishWithoutOnEnded()
 {
     if (playbackState() != FINISHED_STATE) {
         // Let the context dereference this AudioNode.
         context()->notifySourceNodeFinishedProcessing(this);
         setPlaybackState(FINISHED_STATE);
     }
 }
@@ skipping 52 matching lines @@
 
 void AudioScheduledSourceNode::setOnended(PassRefPtrWillBeRawPtr<EventListener> listener)
 {
     audioScheduledSourceHandler().setHasEndedListener();
     setAttributeEventListener(EventTypeNames::ended, listener);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)