TextTrackManager::TextTrackManager(HTMLMediaElement *aMediaElement) : mMediaElement(aMediaElement) , mHasSeeked(false) , mLastTimeMarchesOnCalled(0.0) , mTimeMarchesOnDispatched(false) , performedTrackSelection(false) , mShutdown(false) { nsISupports* parentObject = mMediaElement->OwnerDoc()->GetParentObject(); NS_ENSURE_TRUE_VOID(parentObject); nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(parentObject); mNewCues = new TextTrackCueList(window); mLastActiveCues = new TextTrackCueList(window); mTextTracks = new TextTrackList(window, this); mPendingTextTracks = new TextTrackList(window, this); if (!sParserWrapper) { nsCOMPtr<nsIWebVTTParserWrapper> parserWrapper = do_CreateInstance(NS_WEBVTTPARSERWRAPPER_CONTRACTID); sParserWrapper = parserWrapper; ClearOnShutdown(&sParserWrapper); } mShutdownProxy = new ShutdownObserverProxy(this); }
void Attr::GetTextContentInternal(nsAString& aTextContent) { OwnerDoc()->WarnOnceAbout(nsIDocument::eTextContent); GetValue(aTextContent); }
void Attr::GetNodeValueInternal(nsAString& aNodeValue) { OwnerDoc()->WarnOnceAbout(nsIDocument::eNodeValue); GetValue(aNodeValue); }
void Attr::SetNodeValueInternal(const nsAString& aNodeValue, ErrorResult& aError) { OwnerDoc()->WarnOnceAbout(nsIDocument::eNodeValue); aError = SetValue(aNodeValue); }
nsresult HTMLLinkElement::UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute, bool aNotify) { nsresult rv = nsGenericHTMLElement::UnsetAttr(aNameSpaceID, aAttribute, aNotify); // Since removing href or rel makes us no longer link to a // stylesheet, force updates for those too. if (NS_SUCCEEDED(rv) && aNameSpaceID == kNameSpaceID_None) { if (aAttribute == nsGkAtoms::href || aAttribute == nsGkAtoms::rel || aAttribute == nsGkAtoms::title || aAttribute == nsGkAtoms::media || aAttribute == nsGkAtoms::type) { UpdateStyleSheetInternal(nullptr, nullptr, true); } if (aAttribute == nsGkAtoms::href || aAttribute == nsGkAtoms::rel) { UpdateImport(); } } // The ordering of the parent class's UnsetAttr call and Link::ResetLinkState // is important here! The attribute is not unset until UnsetAttr returns, and // we will need the updated attribute value because notifying the document // that content states have changed will call IntrinsicState, which will try // to get updated information about the visitedness from Link. if (aAttribute == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) { Link::ResetLinkState(!!aNotify, false); CreateAndDispatchEvent(OwnerDoc(), NS_LITERAL_STRING("DOMLinkChanged")); } return rv; }
void HTMLTrackElement::CreateTextTrack() { nsString label, srcLang; GetSrclang(srcLang); GetLabel(label); TextTrackKind kind; if (const nsAttrValue* value = GetParsedAttr(nsGkAtoms::kind)) { kind = static_cast<TextTrackKind>(value->GetEnumValue()); } else { kind = TextTrackKind::Subtitles; } nsISupports* parentObject = OwnerDoc()->GetParentObject(); NS_ENSURE_TRUE_VOID(parentObject); nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(parentObject); mTrack = new TextTrack(window, kind, label, srcLang, TextTrackMode::Disabled, TextTrackReadyState::NotLoaded, TextTrackSource::Track); mTrack->SetTrackElement(this); if (mMediaParent) { mMediaParent->AddTextTrack(mTrack); } }
void nsMappedAttributeElement::NodeInfoChanged(nsIDocument* aOldDoc) { nsHTMLStyleSheet* sheet = OwnerDoc()->GetAttributeStyleSheet(); mAttrs.SetMappedAttrStyleSheet(sheet); nsMappedAttributeElementBase::NodeInfoChanged(aOldDoc); }
TextTrackManager::TextTrackManager(HTMLMediaElement *aMediaElement) : mMediaElement(aMediaElement) { MOZ_COUNT_CTOR(TextTrackManager); mNewCues = new TextTrackCueList(mMediaElement->OwnerDoc()->GetParentObject()); mTextTracks = new TextTrackList(mMediaElement->OwnerDoc()->GetParentObject(), this); mPendingTextTracks = new TextTrackList(mMediaElement->OwnerDoc()->GetParentObject(), this); if (!sParserWrapper) { nsCOMPtr<nsIWebVTTParserWrapper> parserWrapper = do_CreateInstance(NS_WEBVTTPARSERWRAPPER_CONTRACTID); sParserWrapper = parserWrapper; ClearOnShutdown(&sParserWrapper); } }
void Attr::SetTextContentInternal(const nsAString& aTextContent, ErrorResult& aError) { OwnerDoc()->WarnOnceAbout(nsIDocument::eTextContent); SetNodeValueInternal(aTextContent, aError); }
bool nsMappedAttributeElement::SetMappedAttribute(nsIAtom* aName, nsAttrValue& aValue, nsresult* aRetval) { nsHTMLStyleSheet* sheet = OwnerDoc()->GetAttributeStyleSheet(); *aRetval = mAttrsAndChildren.SetAndTakeMappedAttr(aName, aValue, this, sheet); return true; }
void HTMLTrackElement::DispatchTrustedEvent(const nsAString& aName) { nsIDocument* doc = OwnerDoc(); if (!doc) { return; } nsContentUtils::DispatchTrustedEvent(doc, static_cast<nsIContent*>(this), aName, false, false); }
nsresult HTMLLinkElement::SetAttr(int32_t aNameSpaceID, nsIAtom* aName, nsIAtom* aPrefix, const nsAString& aValue, bool aNotify) { nsresult rv = nsGenericHTMLElement::SetAttr(aNameSpaceID, aName, aPrefix, aValue, aNotify); // The ordering of the parent class's SetAttr call and Link::ResetLinkState // is important here! The attribute is not set until SetAttr returns, and // we will need the updated attribute value because notifying the document // that content states have changed will call IntrinsicState, which will try // to get updated information about the visitedness from Link. if (aName == nsGkAtoms::href && kNameSpaceID_None == aNameSpaceID) { Link::ResetLinkState(!!aNotify, true); if (IsInUncomposedDoc()) { CreateAndDispatchEvent(OwnerDoc(), NS_LITERAL_STRING("DOMLinkChanged")); } } if (NS_SUCCEEDED(rv) && aNameSpaceID == kNameSpaceID_None && (aName == nsGkAtoms::href || aName == nsGkAtoms::rel || aName == nsGkAtoms::title || aName == nsGkAtoms::media || aName == nsGkAtoms::type)) { bool dropSheet = false; if (aName == nsGkAtoms::rel) { uint32_t linkTypes = nsStyleLinkElement::ParseLinkTypes(aValue, NodePrincipal()); if (GetSheet()) { dropSheet = !(linkTypes & nsStyleLinkElement::eSTYLESHEET); } else if (linkTypes & eHTMLIMPORT) { UpdateImport(); } else if ((linkTypes & ePRECONNECT) && IsInComposedDoc()) { UpdatePreconnect(); } } if (aName == nsGkAtoms::href) { UpdateImport(); if (IsInComposedDoc()) { UpdatePreconnect(); } } UpdateStyleSheetInternal(nullptr, nullptr, dropSheet || (aName == nsGkAtoms::title || aName == nsGkAtoms::media || aName == nsGkAtoms::type)); } return rv; }
void HTMLVideoElement::CreateVideoWakeLockIfNeeded() { if (!mScreenWakeLock && ShouldCreateVideoWakeLock()) { RefPtr<power::PowerManagerService> pmService = power::PowerManagerService::GetInstance(); NS_ENSURE_TRUE_VOID(pmService); ErrorResult rv; mScreenWakeLock = pmService->NewWakeLock(NS_LITERAL_STRING("video-playing"), OwnerDoc()->GetInnerWindow(), rv); } }
TextTrack* HTMLTrackElement::Track() { if (!mTrack) { // We're expected to always have an internal TextTrack so create // an empty object to return if we don't already have one. mTrack = new TextTrack(OwnerDoc()->GetParentObject()); } return mTrack; }
bool nsMappedAttributeElement::SetAndSwapMappedAttribute(nsAtom* aName, nsAttrValue& aValue, bool* aValueWasSet, nsresult* aRetval) { nsHTMLStyleSheet* sheet = OwnerDoc()->GetAttributeStyleSheet(); *aRetval = mAttrs.SetAndSwapMappedAttr(aName, aValue, this, sheet, aValueWasSet); return true; }
void SVGAnimationElement::UpdateHrefTarget(nsIContent* aNodeForContext, const nsAString& aHrefStr) { nsCOMPtr<nsIURI> targetURI; nsCOMPtr<nsIURI> baseURI = GetBaseURI(); nsContentUtils::NewURIWithDocumentCharset(getter_AddRefs(targetURI), aHrefStr, OwnerDoc(), baseURI); mHrefTarget.Reset(aNodeForContext, targetURI); AnimationTargetChanged(); }
void nsDOMCSSAttributeDeclaration::GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) { NS_ASSERTION(mElement, "Something is severely broken -- there should be an Element here!"); nsIDocument* doc = mElement->OwnerDoc(); aCSSParseEnv.mSheetURI = doc->GetDocumentURI(); aCSSParseEnv.mBaseURI = mElement->GetBaseURI(); aCSSParseEnv.mPrincipal = mElement->NodePrincipal(); aCSSParseEnv.mCSSLoader = doc->CSSLoader(); }
void HTMLVideoElement::WakeLockUpdate() { bool hidden = OwnerDoc()->Hidden(); if (mScreenWakeLock && (mPaused || hidden)) { mScreenWakeLock->Unlock(); mScreenWakeLock = nullptr; return; } if (!mScreenWakeLock && !mPaused && !hidden) { nsCOMPtr<nsIPowerManagerService> pmService = do_GetService(POWERMANAGERSERVICE_CONTRACTID); NS_ENSURE_TRUE_VOID(pmService); pmService->NewWakeLock(NS_LITERAL_STRING("screen"), OwnerDoc()->GetWindow(), getter_AddRefs(mScreenWakeLock)); } }
void HTMLSharedObjectElement::StartObjectLoad(bool aNotify) { // BindToTree can call us asynchronously, and we may be removed from the tree // in the interim if (!IsInComposedDoc() || !OwnerDoc()->IsActive()) { return; } LoadObject(aNotify); SetIsNetworkCreated(false); }
uint32_t HTMLVideoElement::MozDecodedFrames() const { MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread."); if (!IsVideoStatsEnabled()) { return 0; } if (nsContentUtils::ShouldResistFingerprinting(OwnerDoc())) { return nsRFPService::GetSpoofedTotalFrames(TotalPlayTime()); } return mDecoder ? mDecoder->GetFrameStatistics().GetDecodedFrames() : 0; }
bool SVGAElement::IsLink(nsIURI** aURI) const { // To be a clickable XLink for styling and interaction purposes, we require: // // xlink:href - must be set // xlink:type - must be unset or set to "" or set to "simple" // xlink:show - must be unset or set to "", "new" or "replace" // xlink:actuate - must be unset or set to "" or "onRequest" // // For any other values, we're either not a *clickable* XLink, or the end // result is poorly specified. Either way, we return false. static nsIContent::AttrValuesArray sTypeVals[] = { &nsGkAtoms::_empty, &nsGkAtoms::simple, nullptr }; static nsIContent::AttrValuesArray sShowVals[] = { &nsGkAtoms::_empty, &nsGkAtoms::_new, &nsGkAtoms::replace, nullptr }; static nsIContent::AttrValuesArray sActuateVals[] = { &nsGkAtoms::_empty, &nsGkAtoms::onRequest, nullptr }; // Optimization: check for href first for early return bool useXLink = !HasAttr(kNameSpaceID_None, nsGkAtoms::href); const nsAttrValue* href = useXLink ? mAttrsAndChildren.GetAttr(nsGkAtoms::href, kNameSpaceID_XLink) : mAttrsAndChildren.GetAttr(nsGkAtoms::href, kNameSpaceID_None); if (href && FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::type, sTypeVals, eCaseMatters) != nsIContent::ATTR_VALUE_NO_MATCH && FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::show, sShowVals, eCaseMatters) != nsIContent::ATTR_VALUE_NO_MATCH && FindAttrValueIn(kNameSpaceID_XLink, nsGkAtoms::actuate, sActuateVals, eCaseMatters) != nsIContent::ATTR_VALUE_NO_MATCH) { nsCOMPtr<nsIURI> baseURI = GetBaseURI(); // Get absolute URI nsAutoString str; const uint8_t idx = useXLink ? XLINK_HREF : HREF; mStringAttributes[idx].GetAnimValue(str, this); nsContentUtils::NewURIWithDocumentCharset(aURI, str, OwnerDoc(), baseURI); // must promise out param is non-null if we return true return !!*aURI; } *aURI = nullptr; return false; }
void nsAccessNode::Language(nsAString& aLanguage) { aLanguage.Truncate(); if (IsDefunct()) return; nsCoreUtils::GetLanguageFor(mContent, nsnull, aLanguage); if (aLanguage.IsEmpty()) { // Nothing found, so use document's language mContent->OwnerDoc()->GetHeaderData(nsGkAtoms::headerContentLanguage, aLanguage); } }
void HTMLTextAreaElement::FireChangeEventIfNeeded() { nsString value; GetValueInternal(value, true); if (mFocusedValue.Equals(value)) { return; } // Dispatch the change event. mFocusedValue = value; nsContentUtils::DispatchTrustedEvent( OwnerDoc(), static_cast<nsIContent*>(this), NS_LITERAL_STRING("change"), CanBubble::eYes, Cancelable::eNo); }
uint32_t HTMLVideoElement::MozPaintedFrames() { MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread."); if (!IsVideoStatsEnabled()) { return 0; } if (nsContentUtils::ShouldResistFingerprinting(OwnerDoc())) { return nsRFPService::GetSpoofedPresentedFrames(TotalPlayTime(), VideoWidth(), VideoHeight()); } layers::ImageContainer* container = GetImageContainer(); return container ? container->GetPaintCount() : 0; }
void TextTrackManager::DispatchUpdateCueDisplay() { if (!mUpdateCueDisplayDispatched && !IsShutdown() && mMediaElement->IsCurrentlyPlaying()) { WEBVTT_LOG("DispatchUpdateCueDisplay"); nsPIDOMWindowInner* win = mMediaElement->OwnerDoc()->GetInnerWindow(); if (win) { nsGlobalWindowInner::Cast(win)->Dispatch( TaskCategory::Other, NewRunnableMethod("dom::TextTrackManager::UpdateCueDisplay", this, &TextTrackManager::UpdateCueDisplay)); mUpdateCueDisplayDispatched = true; } } }
void HTMLTrackElement::LoadResource() { // Find our 'src' url nsAutoString src; if (!GetAttr(kNameSpaceID_None, nsGkAtoms::src, src)) { return; } nsCOMPtr<nsIURI> uri; nsresult rv = NewURIFromString(src, getter_AddRefs(uri)); NS_ENSURE_TRUE_VOID(NS_SUCCEEDED(rv)); LOG(LogLevel::Info, ("%p Trying to load from src=%s", this, NS_ConvertUTF16toUTF8(src).get())); if (mChannel) { mChannel->Cancel(NS_BINDING_ABORTED); mChannel = nullptr; } // We may already have a TextTrack at this point if GetTrack() has already // been called. This happens, for instance, if script tries to get the // TextTrack before its mTrackElement has been bound to the DOM tree. if (!mTrack) { CreateTextTrack(); } nsCOMPtr<nsIChannel> channel; nsCOMPtr<nsILoadGroup> loadGroup = OwnerDoc()->GetDocumentLoadGroup(); rv = NS_NewChannel(getter_AddRefs(channel), uri, static_cast<Element*>(this), nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_INHERITS, nsIContentPolicy::TYPE_INTERNAL_TRACK, loadGroup); NS_ENSURE_TRUE_VOID(NS_SUCCEEDED(rv)); mListener = new WebVTTListener(this); rv = mListener->LoadResource(); NS_ENSURE_TRUE_VOID(NS_SUCCEEDED(rv)); channel->SetNotificationCallbacks(mListener); LOG(LogLevel::Debug, ("opening webvtt channel")); rv = channel->AsyncOpen2(mListener); NS_ENSURE_TRUE_VOID(NS_SUCCEEDED(rv)); mChannel = channel; }
void HTMLVideoElement::UpdateScreenWakeLock() { bool hidden = OwnerDoc()->Hidden(); if (mScreenWakeLock && (mPaused || hidden)) { ErrorResult rv; mScreenWakeLock->Unlock(rv); NS_WARN_IF_FALSE(!rv.Failed(), "Failed to unlock the wakelock."); mScreenWakeLock = nullptr; return; } if (!mScreenWakeLock && !mPaused && !hidden && HasVideo()) { nsRefPtr<power::PowerManagerService> pmService = power::PowerManagerService::GetInstance(); NS_ENSURE_TRUE_VOID(pmService); ErrorResult rv; mScreenWakeLock = pmService->NewWakeLock(NS_LITERAL_STRING("screen"), OwnerDoc()->GetInnerWindow(), rv); } }
void SVGAnimationElement::UnbindFromTree(bool aDeep, bool aNullParent) { nsSMILAnimationController *controller = OwnerDoc()->GetAnimationController(); if (controller) { controller->UnregisterAnimationElement(this); } mHrefTarget.Unlink(); mTimedElement.DissolveReferences(); AnimationNeedsResample(); SVGAnimationElementBase::UnbindFromTree(aDeep, aNullParent); }
NS_IMETHODIMP Attr::GetOwnerElement(nsIDOMElement** aOwnerElement) { NS_ENSURE_ARG_POINTER(aOwnerElement); OwnerDoc()->WarnOnceAbout(nsIDocument::eOwnerElement); Element* element = GetElement(); if (element) { return CallQueryInterface(element, aOwnerElement); } *aOwnerElement = nullptr; return NS_OK; }
double HTMLVideoElement::MozFrameDelay() { MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread."); if (!IsVideoStatsEnabled() || nsContentUtils::ShouldResistFingerprinting(OwnerDoc())) { return 0.0; } VideoFrameContainer* container = GetVideoFrameContainer(); // Hide negative delays. Frame timing tweaks in the compositor (e.g. // adding a bias value to prevent multiple dropped/duped frames when // frame times are aligned with composition times) may produce apparent // negative delay, but we shouldn't report that. return container ? std::max(0.0, container->GetFrameDelay()) : 0.0; }