Protect AudioScheduledSoureNode::m_startTime and m_endTime.

Source/modules/webaudio/AudioBufferSourceNode.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 396 matching lines @@
     // duration. Otherwise, we want to use the user-specified value, of course.
     if (!m_isDurationGiven)
         m_grainDuration = bufferDuration - m_grainOffset;
 
     if (m_isDurationGiven && loop()) {
         // We're looping a grain with a grain duration specified. Schedule the loop to stop after
         // grainDuration seconds after starting, possibly running the loop multiple times if
         // grainDuration is larger than the buffer duration. The net effect is as if the user called
         // stop(when + grainDuration).
         m_grainDuration = clampTo(m_grainDuration, 0.0, std::numeric_limits<double>::infinity());
-        m_endTime = m_startTime + m_grainDuration;
+        setEndTime(startTime() + m_grainDuration);
     } else {
         m_grainDuration = clampTo(m_grainDuration, 0.0, bufferDuration - m_grainOffset);
     }
 
     // We call timeToSampleFrame here since at playbackRate == 1 we don't want to go through
     // linear interpolation at a sub-sample position since it will degrade the quality. When
     // aligned to the sample-frame the playback will be identical to the PCM data stored in the
     // buffer. Since playbackRate == 1 is very common, it's worth considering quality.
     m_virtualReadIndex = AudioUtilities::timeToSampleFrame(m_grainOffset, buffer->sampleRate());
 }
@@ skipping 60 matching lines @@
     m_grainDuration = grainDuration;
 
     // 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()));
 
     if (buffer())
         clampGrainParameters(buffer());
 
     setPlaybackState(SCHEDULED_STATE);
 }
 
 double AudioBufferSourceHandler::computePlaybackRate()
 {
     double dopplerRate = 1;
@@ skipping 65 matching lines @@
     // would stop playing.  This is intended to handle the (uncommon) scenario where start() has
     // been called but is never connected to the destination (directly or indirectly).  By stopping
     // the node, the node can be collected.  Otherwise, the node will never get collected, leaking
     // memory.
     if (!loop() && buffer() && isPlayingOrScheduled() && m_minPlaybackRate > 0) {
         // Adjust the duration to include the playback rate. Only need to account for rate < 1
         // which makes the sound last longer.  For rate >= 1, the source stops sooner, but that's
         // ok.
         double actualDuration = buffer()->duration() / m_minPlaybackRate;
 
-        double stopTime = m_startTime + actualDuration;
+        double stopTime = startTime() + actualDuration;
 
         // See crbug.com/478301. If a source node is started via start(), the source may not start
         // at that time but one quantum (128 frames) later.  But we compute the stop time based on
         // the start time and the duration, so we end up stopping one quantum early.  Thus, add a
         // little extra time; we just need to stop the source sometime after it should have stopped
         // if it hadn't already.  We don't need to be super precise on when to stop.
         double extraStopTime = kExtraStopFrames / static_cast<double>(context()->sampleRate());
 
         stopTime += extraStopTime;
         if (context()->currentTime() > stopTime) {
@@ skipping 104 matching lines @@
 }
 
 void AudioBufferSourceNode::start(double when, double grainOffset, double grainDuration, ExceptionState& exceptionState)
 {
     audioBufferSourceHandler().start(when, grainOffset, grainDuration, exceptionState);
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)