| /* |
| * Copyright (C) 2011 Google Inc. All rights reserved. |
| * Copyright (C) 2011, 2012, 2013 Apple 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: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "core/html/track/TextTrack.h" |
| |
| #include "bindings/core/v8/ExceptionState.h" |
| #include "bindings/core/v8/ExceptionStatePlaceholder.h" |
| #include "core/dom/ExceptionCode.h" |
| #include "core/html/HTMLMediaElement.h" |
| #include "core/html/track/CueTimeline.h" |
| #include "core/html/track/TextTrackCueList.h" |
| #include "core/html/track/TextTrackList.h" |
| #include "core/html/track/vtt/VTTRegion.h" |
| #include "core/html/track/vtt/VTTRegionList.h" |
| #include "platform/RuntimeEnabledFeatures.h" |
| |
| namespace blink { |
| |
| static const int invalidTrackIndex = -1; |
| |
| const AtomicString& TextTrack::subtitlesKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, subtitles, ("subtitles")); |
| return subtitles; |
| } |
| |
| const AtomicString& TextTrack::captionsKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, captions, ("captions")); |
| return captions; |
| } |
| |
| const AtomicString& TextTrack::descriptionsKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, descriptions, ("descriptions")); |
| return descriptions; |
| } |
| |
| const AtomicString& TextTrack::chaptersKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, chapters, ("chapters")); |
| return chapters; |
| } |
| |
| const AtomicString& TextTrack::metadataKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, metadata, ("metadata")); |
| return metadata; |
| } |
| |
| const AtomicString& TextTrack::disabledKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, disabled, ("disabled")); |
| return disabled; |
| } |
| |
| const AtomicString& TextTrack::hiddenKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, hidden, ("hidden")); |
| return hidden; |
| } |
| |
| const AtomicString& TextTrack::showingKeyword() { |
| DEFINE_STATIC_LOCAL(const AtomicString, showing, ("showing")); |
| return showing; |
| } |
| |
| TextTrack::TextTrack(const AtomicString& kind, |
| const AtomicString& label, |
| const AtomicString& language, |
| const AtomicString& id, |
| TextTrackType type) |
| : TrackBase(WebMediaPlayer::TextTrack, kind, label, language, id), |
| m_cues(nullptr), |
| m_regions(nullptr), |
| m_trackList(nullptr), |
| m_mode(disabledKeyword()), |
| m_trackType(type), |
| m_readinessState(NotLoaded), |
| m_trackIndex(invalidTrackIndex), |
| m_renderedTrackIndex(invalidTrackIndex), |
| m_hasBeenConfigured(false) {} |
| |
| TextTrack::~TextTrack() {} |
| |
| bool TextTrack::isValidKindKeyword(const String& value) { |
| if (value == subtitlesKeyword()) |
| return true; |
| if (value == captionsKeyword()) |
| return true; |
| if (value == descriptionsKeyword()) |
| return true; |
| if (value == chaptersKeyword()) |
| return true; |
| if (value == metadataKeyword()) |
| return true; |
| |
| return false; |
| } |
| |
| void TextTrack::setTrackList(TextTrackList* trackList) { |
| if (!trackList && cueTimeline() && m_cues) |
| cueTimeline()->removeCues(this, m_cues.get()); |
| |
| m_trackList = trackList; |
| invalidateTrackIndex(); |
| } |
| |
| bool TextTrack::isVisualKind() const { |
| return kind() == subtitlesKeyword() || kind() == captionsKeyword(); |
| } |
| |
| void TextTrack::setMode(const AtomicString& mode) { |
| DCHECK(mode == disabledKeyword() || mode == hiddenKeyword() || |
| mode == showingKeyword()); |
| |
| // On setting, if the new value isn't equal to what the attribute would |
| // currently return, the new value must be processed as follows ... |
| if (m_mode == mode) |
| return; |
| |
| if (m_cues && cueTimeline()) { |
| // If mode changes to disabled, remove this track's cues from the client |
| // because they will no longer be accessible from the cues() function. |
| if (mode == disabledKeyword()) |
| cueTimeline()->removeCues(this, m_cues.get()); |
| else if (mode != showingKeyword()) |
| cueTimeline()->hideCues(this, m_cues.get()); |
| } |
| |
| m_mode = mode; |
| |
| if (mode != disabledKeyword() && getReadinessState() == Loaded) { |
| if (m_cues && cueTimeline()) |
| cueTimeline()->addCues(this, m_cues.get()); |
| } |
| |
| if (mediaElement()) |
| mediaElement()->textTrackModeChanged(this); |
| } |
| |
| TextTrackCueList* TextTrack::cues() { |
| // 4.8.10.12.5 If the text track mode ... is not the text track disabled mode, |
| // then the cues attribute must return a live TextTrackCueList object ... |
| // Otherwise, it must return null. When an object is returned, the |
| // same object must be returned each time. |
| // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-cues |
| if (m_mode != disabledKeyword()) |
| return ensureTextTrackCueList(); |
| return nullptr; |
| } |
| |
| void TextTrack::removeAllCues() { |
| if (!m_cues) |
| return; |
| |
| if (cueTimeline()) |
| cueTimeline()->removeCues(this, m_cues.get()); |
| |
| for (size_t i = 0; i < m_cues->length(); ++i) |
| m_cues->anonymousIndexedGetter(i)->setTrack(0); |
| |
| m_cues = nullptr; |
| } |
| |
| void TextTrack::addListOfCues(HeapVector<Member<TextTrackCue>>& listOfNewCues) { |
| TextTrackCueList* cues = ensureTextTrackCueList(); |
| |
| for (auto& newCue : listOfNewCues) { |
| newCue->setTrack(this); |
| cues->add(newCue); |
| } |
| |
| if (cueTimeline() && mode() != disabledKeyword()) |
| cueTimeline()->addCues(this, cues); |
| } |
| |
| TextTrackCueList* TextTrack::activeCues() { |
| // 4.8.10.12.5 If the text track mode ... is not the text track disabled mode, |
| // then the activeCues attribute must return a live TextTrackCueList object |
| // ... whose active flag was set when the script started, in text track cue |
| // order. Otherwise, it must return null. When an object is returned, the same |
| // object must be returned each time. |
| // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-activecues |
| if (!m_cues || m_mode == disabledKeyword()) |
| return nullptr; |
| |
| if (!m_activeCues) |
| m_activeCues = TextTrackCueList::create(); |
| |
| m_cues->collectActiveCues(*m_activeCues); |
| return m_activeCues; |
| } |
| |
| void TextTrack::addCue(TextTrackCue* cue) { |
| DCHECK(cue); |
| |
| // TODO(93143): Add spec-compliant behavior for negative time values. |
| if (std::isnan(cue->startTime()) || std::isnan(cue->endTime()) || |
| cue->startTime() < 0 || cue->endTime() < 0) |
| return; |
| |
| // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-texttrack-addcue |
| |
| // The addCue(cue) method of TextTrack objects, when invoked, must run the |
| // following steps: |
| |
| // (Steps 1 and 2 - pertaining to association of rendering rules - are not |
| // implemented.) |
| |
| // 3. If the given cue is in a text track list of cues, then remove cue |
| // from that text track list of cues. |
| if (TextTrack* cueTrack = cue->track()) |
| cueTrack->removeCue(cue, ASSERT_NO_EXCEPTION); |
| |
| // 4. Add cue to the method's TextTrack object's text track's text track list |
| // of cues. |
| cue->setTrack(this); |
| ensureTextTrackCueList()->add(cue); |
| |
| if (cueTimeline() && m_mode != disabledKeyword()) |
| cueTimeline()->addCue(this, cue); |
| } |
| |
| void TextTrack::removeCue(TextTrackCue* cue, ExceptionState& exceptionState) { |
| DCHECK(cue); |
| |
| // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-texttrack-removecue |
| |
| // The removeCue(cue) method of TextTrack objects, when invoked, must run the |
| // following steps: |
| |
| // 1. If the given cue is not currently listed in the method's TextTrack |
| // object's text track's text track list of cues, then throw a NotFoundError |
| // exception. |
| if (cue->track() != this) { |
| exceptionState.throwDOMException( |
| NotFoundError, |
| "The specified cue is not listed in the TextTrack's list of cues."); |
| return; |
| } |
| |
| // cue->track() == this implies that cue is in this track's list of cues, |
| // so this track should have a list of cues and the cue being removed |
| // should be in it. |
| DCHECK(m_cues); |
| |
| // 2. Remove cue from the method's TextTrack object's text track's text track |
| // list of cues. |
| bool wasRemoved = m_cues->remove(cue); |
| DCHECK(wasRemoved); |
| |
| // If the cue is active, a timeline needs to be available. |
| DCHECK(!cue->isActive() || cueTimeline()); |
| |
| cue->setTrack(0); |
| |
| if (cueTimeline()) |
| cueTimeline()->removeCue(this, cue); |
| } |
| |
| VTTRegionList* TextTrack::ensureVTTRegionList() { |
| if (!m_regions) |
| m_regions = VTTRegionList::create(); |
| |
| return m_regions.get(); |
| } |
| |
| VTTRegionList* TextTrack::regions() { |
| // If the text track mode of the text track that the TextTrack object |
| // represents is not the text track disabled mode, then the regions |
| // attribute must return a live VTTRegionList object that represents |
| // the text track list of regions of the text track. Otherwise, it must |
| // return null. When an object is returned, the same object must be returned |
| // each time. |
| if (RuntimeEnabledFeatures::webVTTRegionsEnabled() && |
| m_mode != disabledKeyword()) |
| return ensureVTTRegionList(); |
| return nullptr; |
| } |
| |
| void TextTrack::addRegion(VTTRegion* region) { |
| if (!region) |
| return; |
| |
| VTTRegionList* regionList = ensureVTTRegionList(); |
| |
| // 1. If the given region is in a text track list of regions, then remove |
| // region from that text track list of regions. |
| TextTrack* regionTrack = region->track(); |
| if (regionTrack && regionTrack != this) |
| regionTrack->removeRegion(region, ASSERT_NO_EXCEPTION); |
| |
| // 2. If the method's TextTrack object's text track list of regions contains |
| // a region with the same identifier as region replace the values of that |
| // region's width, height, anchor point, viewport anchor point and scroll |
| // attributes with those of region. |
| VTTRegion* existingRegion = regionList->getRegionById(region->id()); |
| if (existingRegion) { |
| existingRegion->updateParametersFromRegion(region); |
| return; |
| } |
| |
| // Otherwise: add region to the method's TextTrack object's text track |
| // list of regions. |
| region->setTrack(this); |
| regionList->add(region); |
| } |
| |
| void TextTrack::removeRegion(VTTRegion* region, |
| ExceptionState& exceptionState) { |
| if (!region) |
| return; |
| |
| // 1. If the given region is not currently listed in the method's TextTrack |
| // object's text track list of regions, then throw a NotFoundError exception. |
| if (region->track() != this) { |
| exceptionState.throwDOMException(NotFoundError, |
| "The specified region is not listed in " |
| "the TextTrack's list of regions."); |
| return; |
| } |
| |
| if (!m_regions || !m_regions->remove(region)) { |
| exceptionState.throwDOMException(InvalidStateError, |
| "Failed to remove the specified region."); |
| return; |
| } |
| |
| region->setTrack(0); |
| } |
| |
| void TextTrack::cueWillChange(TextTrackCue* cue) { |
| // The cue may need to be repositioned in the media element's interval tree, |
| // may need to be re-rendered, etc, so remove it before the modification... |
| if (cueTimeline()) |
| cueTimeline()->removeCue(this, cue); |
| } |
| |
| void TextTrack::cueDidChange(TextTrackCue* cue) { |
| // This method is called through cue->track(), which should imply that this |
| // track has a list of cues. |
| DCHECK(m_cues && cue->track() == this); |
| |
| // Make sure the TextTrackCueList order is up to date. |
| // FIXME: Only need to do this if the change was to any of the timestamps. |
| m_cues->updateCueIndex(cue); |
| |
| // Since a call to cueDidChange is always preceded by a call to |
| // cueWillChange, the cue should no longer be active when we reach this |
| // point (since it was removed from the timeline in cueWillChange). |
| DCHECK(!cue->isActive()); |
| |
| if (m_mode == disabledKeyword()) |
| return; |
| |
| // ... and add it back again if the track is enabled. |
| if (cueTimeline()) |
| cueTimeline()->addCue(this, cue); |
| } |
| |
| int TextTrack::trackIndex() { |
| DCHECK(m_trackList); |
| |
| if (m_trackIndex == invalidTrackIndex) |
| m_trackIndex = m_trackList->getTrackIndex(this); |
| |
| return m_trackIndex; |
| } |
| |
| void TextTrack::invalidateTrackIndex() { |
| m_trackIndex = invalidTrackIndex; |
| m_renderedTrackIndex = invalidTrackIndex; |
| } |
| |
| bool TextTrack::isRendered() const { |
| return m_mode == showingKeyword() && isVisualKind(); |
| } |
| |
| bool TextTrack::canBeRendered() const { |
| // A track can be displayed when it's of kind captions or subtitles and hasn't |
| // failed to load. |
| return getReadinessState() != FailedToLoad && isVisualKind(); |
| } |
| |
| TextTrackCueList* TextTrack::ensureTextTrackCueList() { |
| if (!m_cues) |
| m_cues = TextTrackCueList::create(); |
| |
| return m_cues.get(); |
| } |
| |
| int TextTrack::trackIndexRelativeToRenderedTracks() { |
| DCHECK(m_trackList); |
| |
| if (m_renderedTrackIndex == invalidTrackIndex) |
| m_renderedTrackIndex = |
| m_trackList->getTrackIndexRelativeToRenderedTracks(this); |
| |
| return m_renderedTrackIndex; |
| } |
| |
| const AtomicString& TextTrack::interfaceName() const { |
| return EventTargetNames::TextTrack; |
| } |
| |
| ExecutionContext* TextTrack::getExecutionContext() const { |
| HTMLMediaElement* owner = mediaElement(); |
| return owner ? owner->getExecutionContext() : 0; |
| } |
| |
| HTMLMediaElement* TextTrack::mediaElement() const { |
| return m_trackList ? m_trackList->owner() : 0; |
| } |
| |
| CueTimeline* TextTrack::cueTimeline() const { |
| return mediaElement() ? &mediaElement()->cueTimeline() : nullptr; |
| } |
| |
| Node* TextTrack::owner() const { |
| return mediaElement(); |
| } |
| |
| DEFINE_TRACE(TextTrack) { |
| visitor->trace(m_cues); |
| visitor->trace(m_activeCues); |
| visitor->trace(m_regions); |
| visitor->trace(m_trackList); |
| TrackBase::trace(visitor); |
| EventTargetWithInlineData::trace(visitor); |
| } |
| |
| DEFINE_TRACE_WRAPPERS(TextTrack) { |
| visitor->traceWrappers(m_cues); |
| } |
| } // namespace blink |