void AnimationTimeline::serviceAnimations(TimingUpdateReason reason)
{
TRACE_EVENT0("blink", "AnimationTimeline::serviceAnimations");
m_lastCurrentTimeInternal = currentTimeInternal();
HeapVector<Member<Animation>> animations;
animations.reserveInitialCapacity(m_animationsNeedingUpdate.size());
for (Animation* animation : m_animationsNeedingUpdate)
animations.append(animation);
std::sort(animations.begin(), animations.end(), Animation::hasLowerPriority);
for (Animation* animation : animations) {
if (!animation->update(reason))
m_animationsNeedingUpdate.remove(animation);
}
ASSERT(m_outdatedAnimationCount == 0);
ASSERT(m_lastCurrentTimeInternal == currentTimeInternal() || (std::isnan(currentTimeInternal()) && std::isnan(m_lastCurrentTimeInternal)));
#if ENABLE(ASSERT)
for (const auto& animation : m_animationsNeedingUpdate)
ASSERT(!animation->outdated());
#endif
}
HeapVector<Member<Animation>> AnimationTimeline::getAnimations()
{
HeapVector<Member<Animation>> animations;
for (const auto& animation : m_animations) {
if (animation->effect() && (animation->effect()->isCurrent() || animation->effect()->isInEffect()))
animations.append(animation);
}
std::sort(animations.begin(), animations.end(), compareAnimations);
return animations;
}
void RTCDTMFSender::scheduledEventTimerFired(TimerBase*) {
if (m_stopped)
return;
HeapVector<Member<Event>> events;
events.swap(m_scheduledEvents);
HeapVector<Member<Event>>::iterator it = events.begin();
for (; it != events.end(); ++it)
dispatchEvent((*it).release());
}
void RTCDataChannel::scheduledEventTimerFired(Timer<RTCDataChannel>*)
{
HeapVector<Member<Event>> events;
events.swap(m_scheduledEvents);
HeapVector<Member<Event>>::iterator it = events.begin();
for (; it != events.end(); ++it)
dispatchEvent((*it).release());
events.clear();
}
void MediaStream::scheduledEventTimerFired(TimerBase*) {
if (m_executionContext->isContextDestroyed())
return;
HeapVector<Member<Event>> events;
events.swap(m_scheduledEvents);
HeapVector<Member<Event>>::iterator it = events.begin();
for (; it != events.end(); ++it)
dispatchEvent((*it).release());
events.clear();
}
void CueTimeline::updateActiveCues(double movieTime) {
// 4.8.10.8 Playing the media resource
// If the current playback position changes while the steps are running,
// then the user agent must wait for the steps to complete, and then must
// immediately rerun the steps.
if (ignoreUpdateRequests())
return;
HTMLMediaElement& mediaElement = this->mediaElement();
// Don't run the "time marches on" algorithm if the document has been
// detached. This primarily guards against dispatch of events w/
// HTMLTrackElement targets.
if (mediaElement.document().isDetached())
return;
// https://html.spec.whatwg.org/#time-marches-on
// 1 - Let current cues be a list of cues, initialized to contain all the
// cues of all the hidden, showing, or showing by default text tracks of the
// media element (not the disabled ones) whose start times are less than or
// equal to the current playback position and whose end times are greater
// than the current playback position.
CueList currentCues;
// The user agent must synchronously unset [the text track cue active] flag
// whenever ... the media element's readyState is changed back to
// kHaveNothing.
if (mediaElement.getReadyState() != HTMLMediaElement::kHaveNothing &&
mediaElement.webMediaPlayer())
currentCues =
m_cueTree.allOverlaps(m_cueTree.createInterval(movieTime, movieTime));
CueList previousCues;
CueList missedCues;
// 2 - Let other cues be a list of cues, initialized to contain all the cues
// of hidden, showing, and showing by default text tracks of the media
// element that are not present in current cues.
previousCues = m_currentlyActiveCues;
// 3 - Let last time be the current playback position at the time this
// algorithm was last run for this media element, if this is not the first
// time it has run.
double lastTime = m_lastUpdateTime;
double lastSeekTime = mediaElement.lastSeekTime();
// 4 - If the current playback position has, since the last time this
// algorithm was run, only changed through its usual monotonic increase
// during normal playback, then let missed cues be the list of cues in other
// cues whose start times are greater than or equal to last time and whose
// end times are less than or equal to the current playback position.
// Otherwise, let missed cues be an empty list.
if (lastTime >= 0 && lastSeekTime < movieTime) {
CueList potentiallySkippedCues =
m_cueTree.allOverlaps(m_cueTree.createInterval(lastTime, movieTime));
for (CueInterval cue : potentiallySkippedCues) {
// Consider cues that may have been missed since the last seek time.
if (cue.low() > std::max(lastSeekTime, lastTime) &&
cue.high() < movieTime)
missedCues.append(cue);
}
}
m_lastUpdateTime = movieTime;
// 5 - If the time was reached through the usual monotonic increase of the
// current playback position during normal playback, and if the user agent
// has not fired a timeupdate event at the element in the past 15 to 250ms
// and is not still running event handlers for such an event, then the user
// agent must queue a task to fire a simple event named timeupdate at the
// element. (In the other cases, such as explicit seeks, relevant events get
// fired as part of the overall process of changing the current playback
// position.)
if (!mediaElement.seeking() && lastSeekTime < lastTime)
mediaElement.scheduleTimeupdateEvent(true);
// Explicitly cache vector sizes, as their content is constant from here.
size_t missedCuesSize = missedCues.size();
size_t previousCuesSize = previousCues.size();
// 6 - If all of the cues in current cues have their text track cue active
// flag set, none of the cues in other cues have their text track cue active
// flag set, and missed cues is empty, then abort these steps.
bool activeSetChanged = missedCuesSize;
for (size_t i = 0; !activeSetChanged && i < previousCuesSize; ++i) {
if (!currentCues.contains(previousCues[i]) &&
previousCues[i].data()->isActive())
activeSetChanged = true;
}
for (CueInterval currentCue : currentCues) {
// Notify any cues that are already active of the current time to mark
// past and future nodes. Any inactive cues have an empty display state;
// they will be notified of the current time when the display state is
// updated.
if (currentCue.data()->isActive())
currentCue.data()->updatePastAndFutureNodes(movieTime);
else
activeSetChanged = true;
}
if (!activeSetChanged)
return;
// 7 - If the time was reached through the usual monotonic increase of the
// current playback position during normal playback, and there are cues in
// other cues that have their text track cue pause-on-exi flag set and that
// either have their text track cue active flag set or are also in missed
// cues, then immediately pause the media element.
for (size_t i = 0; !mediaElement.paused() && i < previousCuesSize; ++i) {
if (previousCues[i].data()->pauseOnExit() &&
previousCues[i].data()->isActive() &&
!currentCues.contains(previousCues[i]))
mediaElement.pause();
}
for (size_t i = 0; !mediaElement.paused() && i < missedCuesSize; ++i) {
if (missedCues[i].data()->pauseOnExit())
mediaElement.pause();
}
// 8 - Let events be a list of tasks, initially empty. Each task in this
// list will be associated with a text track, a text track cue, and a time,
// which are used to sort the list before the tasks are queued.
HeapVector<std::pair<double, Member<TextTrackCue>>> eventTasks;
// 8 - Let affected tracks be a list of text tracks, initially empty.
HeapVector<Member<TextTrack>> affectedTracks;
for (const auto& missedCue : missedCues) {
// 9 - For each text track cue in missed cues, prepare an event named enter
// for the TextTrackCue object with the text track cue start time.
eventTasks.append(
std::make_pair(missedCue.data()->startTime(), missedCue.data()));
// 10 - For each text track [...] in missed cues, prepare an event
// named exit for the TextTrackCue object with the with the later of
// the text track cue end time and the text track cue start time.
// Note: An explicit task is added only if the cue is NOT a zero or
// negative length cue. Otherwise, the need for an exit event is
// checked when these tasks are actually queued below. This doesn't
// affect sorting events before dispatch either, because the exit
// event has the same time as the enter event.
if (missedCue.data()->startTime() < missedCue.data()->endTime()) {
eventTasks.append(
std::make_pair(missedCue.data()->endTime(), missedCue.data()));
}
}
for (const auto& previousCue : previousCues) {
// 10 - For each text track cue in other cues that has its text
// track cue active flag set prepare an event named exit for the
// TextTrackCue object with the text track cue end time.
if (!currentCues.contains(previousCue)) {
eventTasks.append(
std::make_pair(previousCue.data()->endTime(), previousCue.data()));
}
}
for (const auto& currentCue : currentCues) {
// 11 - For each text track cue in current cues that does not have its
// text track cue active flag set, prepare an event named enter for the
// TextTrackCue object with the text track cue start time.
if (!previousCues.contains(currentCue)) {
eventTasks.append(
std::make_pair(currentCue.data()->startTime(), currentCue.data()));
}
}
// 12 - Sort the tasks in events in ascending time order (tasks with earlier
// times first).
nonCopyingSort(eventTasks.begin(), eventTasks.end(), eventTimeCueCompare);
for (const auto& task : eventTasks) {
if (!affectedTracks.contains(task.second->track()))
affectedTracks.append(task.second->track());
// 13 - Queue each task in events, in list order.
// Each event in eventTasks may be either an enterEvent or an exitEvent,
// depending on the time that is associated with the event. This
// correctly identifies the type of the event, if the startTime is
// less than the endTime in the cue.
if (task.second->startTime() >= task.second->endTime()) {
mediaElement.scheduleEvent(
createEventWithTarget(EventTypeNames::enter, task.second.get()));
mediaElement.scheduleEvent(
createEventWithTarget(EventTypeNames::exit, task.second.get()));
} else {
bool isEnterEvent = task.first == task.second->startTime();
AtomicString eventName =
isEnterEvent ? EventTypeNames::enter : EventTypeNames::exit;
mediaElement.scheduleEvent(
createEventWithTarget(eventName, task.second.get()));
}
}
// 14 - Sort affected tracks in the same order as the text tracks appear in
// the media element's list of text tracks, and remove duplicates.
nonCopyingSort(affectedTracks.begin(), affectedTracks.end(),
trackIndexCompare);
// 15 - For each text track in affected tracks, in the list order, queue a
// task to fire a simple event named cuechange at the TextTrack object, and,
// ...
for (const auto& track : affectedTracks) {
mediaElement.scheduleEvent(
createEventWithTarget(EventTypeNames::cuechange, track.get()));
// ... if the text track has a corresponding track element, to then fire a
// simple event named cuechange at the track element as well.
if (track->trackType() == TextTrack::TrackElement) {
HTMLTrackElement* trackElement =
static_cast<LoadableTextTrack*>(track.get())->trackElement();
DCHECK(trackElement);
mediaElement.scheduleEvent(
createEventWithTarget(EventTypeNames::cuechange, trackElement));
}
}
// 16 - Set the text track cue active flag of all the cues in the current
// cues, and unset the text track cue active flag of all the cues in the
// other cues.
for (const auto& cue : currentCues)
cue.data()->setIsActive(true);
for (const auto& previousCue : previousCues) {
if (!currentCues.contains(previousCue)) {
TextTrackCue* cue = previousCue.data();
cue->setIsActive(false);
cue->removeDisplayTree();
}
}
// Update the current active cues.
m_currentlyActiveCues = currentCues;
mediaElement.updateTextTrackDisplay();
}