HTMLTrackElement.cpp [plain text]
#include "config.h"
#if ENABLE(VIDEO_TRACK)
#include "HTMLTrackElement.h"
#include "ContentSecurityPolicy.h"
#include "Event.h"
#include "HTMLMediaElement.h"
#include "HTMLNames.h"
#include "Logging.h"
#include "RuntimeEnabledFeatures.h"
#include <wtf/text/CString.h>
namespace WebCore {
using namespace HTMLNames;
#if !LOG_DISABLED
static String urlForLoggingTrack(const URL& url)
{
static const unsigned maximumURLLengthForLogging = 128;
if (url.string().length() < maximumURLLengthForLogging)
return url.string();
return url.string().substring(0, maximumURLLengthForLogging) + "...";
}
#endif
inline HTMLTrackElement::HTMLTrackElement(const QualifiedName& tagName, Document& document)
: HTMLElement(tagName, document)
, m_loadTimer(*this, &HTMLTrackElement::loadTimerFired)
{
LOG(Media, "HTMLTrackElement::HTMLTrackElement - %p", this);
ASSERT(hasTagName(trackTag));
}
HTMLTrackElement::~HTMLTrackElement()
{
if (m_track)
m_track->clearClient();
}
Ref<HTMLTrackElement> HTMLTrackElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(*new HTMLTrackElement(tagName, document));
}
Node::InsertionNotificationRequest HTMLTrackElement::insertedInto(ContainerNode& insertionPoint)
{
scheduleLoad();
HTMLElement::insertedInto(insertionPoint);
HTMLMediaElement* parent = mediaElement();
if (&insertionPoint == parent) {
ensureTrack();
parent->didAddTextTrack(this);
}
return InsertionDone;
}
void HTMLTrackElement::removedFrom(ContainerNode& insertionPoint)
{
if (!parentNode() && is<HTMLMediaElement>(insertionPoint))
downcast<HTMLMediaElement>(insertionPoint).didRemoveTextTrack(this);
HTMLElement::removedFrom(insertionPoint);
}
void HTMLTrackElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (RuntimeEnabledFeatures::sharedFeatures().webkitVideoTrackEnabled()) {
if (name == srcAttr) {
if (!value.isEmpty())
scheduleLoad();
else if (m_track)
m_track->removeAllCues();
} else if (name == kindAttr)
track()->setKind(value.lower());
else if (name == labelAttr)
track()->setLabel(value);
else if (name == srclangAttr)
track()->setLanguage(value);
else if (name == defaultAttr)
track()->setIsDefault(!value.isNull());
}
HTMLElement::parseAttribute(name, value);
}
String HTMLTrackElement::kind()
{
return track()->kind();
}
void HTMLTrackElement::setKind(const String& kind)
{
setAttribute(kindAttr, kind);
}
String HTMLTrackElement::srclang() const
{
return getAttribute(srclangAttr);
}
void HTMLTrackElement::setSrclang(const String& srclang)
{
setAttribute(srclangAttr, srclang);
}
String HTMLTrackElement::label() const
{
return getAttribute(labelAttr);
}
void HTMLTrackElement::setLabel(const String& label)
{
setAttribute(labelAttr, label);
}
bool HTMLTrackElement::isDefault() const
{
return fastHasAttribute(defaultAttr);
}
void HTMLTrackElement::setIsDefault(bool isDefault)
{
setBooleanAttribute(defaultAttr, isDefault);
}
LoadableTextTrack& HTMLTrackElement::ensureTrack()
{
if (!m_track) {
String kind = getAttribute(kindAttr).lower();
if (!TextTrack::isValidKindKeyword(kind))
kind = TextTrack::subtitlesKeyword();
m_track = LoadableTextTrack::create(this, kind, label(), srclang());
} else
m_track->setTrackElement(this);
return *m_track;
}
TextTrack* HTMLTrackElement::track()
{
return &ensureTrack();
}
bool HTMLTrackElement::isURLAttribute(const Attribute& attribute) const
{
return attribute.name() == srcAttr || HTMLElement::isURLAttribute(attribute);
}
void HTMLTrackElement::scheduleLoad()
{
if (m_loadTimer.isActive())
return;
if (!RuntimeEnabledFeatures::sharedFeatures().webkitVideoTrackEnabled())
return;
if (ensureTrack().mode() != TextTrack::hiddenKeyword() && ensureTrack().mode() != TextTrack::showingKeyword())
return;
if (!mediaElement())
return;
m_loadTimer.startOneShot(0);
}
void HTMLTrackElement::loadTimerFired()
{
if (!fastHasAttribute(srcAttr))
return;
setReadyState(HTMLTrackElement::LOADING);
URL url = getNonEmptyURLAttribute(srcAttr);
if (!canLoadURL(url)) {
didCompleteLoad(HTMLTrackElement::Failure);
return;
}
ensureTrack().scheduleLoad(url);
}
bool HTMLTrackElement::canLoadURL(const URL& url)
{
if (!RuntimeEnabledFeatures::sharedFeatures().webkitVideoTrackEnabled())
return false;
HTMLMediaElement* parent = mediaElement();
if (!parent)
return false;
if (url.isEmpty())
return false;
if (!document().contentSecurityPolicy()->allowMediaFromSource(url, isInUserAgentShadowTree())) {
LOG(Media, "HTMLTrackElement::canLoadURL(%s) -> rejected by Content Security Policy", urlForLoggingTrack(url).utf8().data());
return false;
}
return dispatchBeforeLoadEvent(url.string());
}
void HTMLTrackElement::didCompleteLoad(LoadStatus status)
{
if (status == Failure) {
setReadyState(HTMLTrackElement::TRACK_ERROR);
dispatchEvent(Event::create(eventNames().errorEvent, false, false), IGNORE_EXCEPTION);
return;
}
setReadyState(HTMLTrackElement::LOADED);
dispatchEvent(Event::create(eventNames().loadEvent, false, false), IGNORE_EXCEPTION);
}
COMPILE_ASSERT(HTMLTrackElement::NONE == static_cast<HTMLTrackElement::ReadyState>(TextTrack::NotLoaded), TextTrackEnumNotLoaded_Is_Wrong_Should_Be_HTMLTrackElementEnumNONE);
COMPILE_ASSERT(HTMLTrackElement::LOADING == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loading), TextTrackEnumLoadingIsWrong_ShouldBe_HTMLTrackElementEnumLOADING);
COMPILE_ASSERT(HTMLTrackElement::LOADED == static_cast<HTMLTrackElement::ReadyState>(TextTrack::Loaded), TextTrackEnumLoaded_Is_Wrong_Should_Be_HTMLTrackElementEnumLOADED);
COMPILE_ASSERT(HTMLTrackElement::TRACK_ERROR == static_cast<HTMLTrackElement::ReadyState>(TextTrack::FailedToLoad), TextTrackEnumFailedToLoad_Is_Wrong_Should_Be_HTMLTrackElementEnumTRACK_ERROR);
void HTMLTrackElement::setReadyState(ReadyState state)
{
ensureTrack().setReadinessState(static_cast<TextTrack::ReadinessState>(state));
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackReadyStateChanged(m_track.get());
}
HTMLTrackElement::ReadyState HTMLTrackElement::readyState()
{
return static_cast<ReadyState>(ensureTrack().readinessState());
}
const AtomicString& HTMLTrackElement::mediaElementCrossOriginAttribute() const
{
if (HTMLMediaElement* parent = mediaElement())
return parent->fastGetAttribute(HTMLNames::crossoriginAttr);
return nullAtom;
}
void HTMLTrackElement::textTrackKindChanged(TextTrack* track)
{
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackKindChanged(track);
}
void HTMLTrackElement::textTrackModeChanged(TextTrack* track)
{
if (readyState() == HTMLTrackElement::NONE)
scheduleLoad();
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackModeChanged(track);
}
void HTMLTrackElement::textTrackAddCues(TextTrack* track, const TextTrackCueList* cues)
{
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackAddCues(track, cues);
}
void HTMLTrackElement::textTrackRemoveCues(TextTrack* track, const TextTrackCueList* cues)
{
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackRemoveCues(track, cues);
}
void HTMLTrackElement::textTrackAddCue(TextTrack* track, PassRefPtr<TextTrackCue> cue)
{
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackAddCue(track, cue);
}
void HTMLTrackElement::textTrackRemoveCue(TextTrack* track, PassRefPtr<TextTrackCue> cue)
{
if (HTMLMediaElement* parent = mediaElement())
return parent->textTrackRemoveCue(track, cue);
}
HTMLMediaElement* HTMLTrackElement::mediaElement() const
{
Element* parent = parentElement();
if (is<HTMLMediaElement>(parent))
return downcast<HTMLMediaElement>(parentNode());
return nullptr;
}
}
#endif