зеркало из https://github.com/mozilla/gecko-dev.git
2371 строка
73 KiB
C++
2371 строка
73 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
||
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
||
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||
|
||
/*
|
||
* Base class for all element classes; this provides an implementation
|
||
* of DOM Core's nsIDOMElement, implements nsIContent, provides
|
||
* utility methods for subclasses, and so forth.
|
||
*/
|
||
|
||
#include "mozilla/ArrayUtils.h"
|
||
#include "mozilla/Likely.h"
|
||
#include "mozilla/MemoryReporting.h"
|
||
#include "mozilla/StaticPtr.h"
|
||
|
||
#include "mozilla/dom/FragmentOrElement.h"
|
||
|
||
#include "mozilla/AsyncEventDispatcher.h"
|
||
#include "mozilla/DeclarationBlockInlines.h"
|
||
#include "mozilla/EffectSet.h"
|
||
#include "mozilla/EventDispatcher.h"
|
||
#include "mozilla/EventListenerManager.h"
|
||
#include "mozilla/EventStates.h"
|
||
#include "mozilla/HTMLEditor.h"
|
||
#include "mozilla/RestyleManager.h"
|
||
#include "mozilla/TextEditor.h"
|
||
#include "mozilla/URLExtraData.h"
|
||
#include "mozilla/dom/Attr.h"
|
||
#include "nsDOMAttributeMap.h"
|
||
#include "nsAtom.h"
|
||
#include "mozilla/dom/NodeInfo.h"
|
||
#include "mozilla/dom/Event.h"
|
||
#include "nsIDocumentInlines.h"
|
||
#include "nsIDocumentEncoder.h"
|
||
#include "nsIDOMNodeList.h"
|
||
#include "nsIContentIterator.h"
|
||
#include "nsFocusManager.h"
|
||
#include "nsILinkHandler.h"
|
||
#include "nsIScriptGlobalObject.h"
|
||
#include "nsIURL.h"
|
||
#include "nsNetUtil.h"
|
||
#include "nsIFrame.h"
|
||
#include "nsIAnonymousContentCreator.h"
|
||
#include "nsIPresShell.h"
|
||
#include "nsPresContext.h"
|
||
#include "nsStyleConsts.h"
|
||
#include "nsString.h"
|
||
#include "nsUnicharUtils.h"
|
||
#include "nsIDOMEvent.h"
|
||
#include "nsDOMCID.h"
|
||
#include "nsIServiceManager.h"
|
||
#include "nsDOMCSSAttrDeclaration.h"
|
||
#include "nsNameSpaceManager.h"
|
||
#include "nsContentList.h"
|
||
#include "nsDOMTokenList.h"
|
||
#include "nsXBLPrototypeBinding.h"
|
||
#include "nsError.h"
|
||
#include "nsDOMString.h"
|
||
#include "nsIScriptSecurityManager.h"
|
||
#include "mozilla/InternalMutationEvent.h"
|
||
#include "mozilla/MouseEvents.h"
|
||
#include "nsNodeUtils.h"
|
||
#include "nsDocument.h"
|
||
#include "nsAttrValueOrString.h"
|
||
#include "nsQueryObject.h"
|
||
#ifdef MOZ_XUL
|
||
#include "nsXULElement.h"
|
||
#endif /* MOZ_XUL */
|
||
#include "nsFrameSelection.h"
|
||
#ifdef DEBUG
|
||
#include "nsRange.h"
|
||
#endif
|
||
|
||
#include "nsBindingManager.h"
|
||
#include "nsFrameLoader.h"
|
||
#include "nsXBLBinding.h"
|
||
#include "nsPIDOMWindow.h"
|
||
#include "nsPIBoxObject.h"
|
||
#include "nsSVGUtils.h"
|
||
#include "nsLayoutUtils.h"
|
||
#include "nsGkAtoms.h"
|
||
#include "nsContentUtils.h"
|
||
#include "nsTextFragment.h"
|
||
#include "nsContentCID.h"
|
||
#include "nsWindowSizes.h"
|
||
|
||
#include "nsIDOMEventListener.h"
|
||
#include "nsIWebNavigation.h"
|
||
#include "nsIBaseWindow.h"
|
||
#include "nsIWidget.h"
|
||
|
||
#include "nsNodeInfoManager.h"
|
||
#include "nsICategoryManager.h"
|
||
#include "nsGenericHTMLElement.h"
|
||
#include "nsContentCreatorFunctions.h"
|
||
#include "nsIControllers.h"
|
||
#include "nsView.h"
|
||
#include "nsViewManager.h"
|
||
#include "nsIScrollableFrame.h"
|
||
#include "ChildIterator.h"
|
||
#include "nsTextNode.h"
|
||
#include "mozilla/dom/NodeListBinding.h"
|
||
|
||
#include "nsCCUncollectableMarker.h"
|
||
|
||
#include "mozAutoDocUpdate.h"
|
||
|
||
#include "mozilla/Sprintf.h"
|
||
#include "nsDOMMutationObserver.h"
|
||
#include "nsWrapperCacheInlines.h"
|
||
#include "nsCycleCollector.h"
|
||
#include "xpcpublic.h"
|
||
#include "nsIScriptError.h"
|
||
#include "mozilla/Telemetry.h"
|
||
|
||
#include "mozilla/CORSMode.h"
|
||
|
||
#include "mozilla/dom/ShadowRoot.h"
|
||
#include "mozilla/dom/HTMLSlotElement.h"
|
||
#include "mozilla/dom/HTMLTemplateElement.h"
|
||
#include "mozilla/dom/SVGUseElement.h"
|
||
|
||
#include "nsStyledElement.h"
|
||
#include "nsIContentInlines.h"
|
||
#include "nsChildContentList.h"
|
||
#include "mozilla/BloomFilter.h"
|
||
|
||
using namespace mozilla;
|
||
using namespace mozilla::dom;
|
||
|
||
int32_t nsIContent::sTabFocusModel = eTabFocus_any;
|
||
bool nsIContent::sTabFocusModelAppliesToXUL = false;
|
||
uint64_t nsMutationGuard::sGeneration = 0;
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CLASS(nsIContent)
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsIContent)
|
||
MOZ_ASSERT_UNREACHABLE("Our subclasses don't call us");
|
||
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsIContent)
|
||
MOZ_ASSERT_UNREACHABLE("Our subclasses don't call us");
|
||
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
||
|
||
NS_INTERFACE_MAP_BEGIN(nsIContent)
|
||
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
||
// Don't bother to QI to cycle collection, because our CC impl is
|
||
// not doing anything anyway.
|
||
NS_INTERFACE_MAP_ENTRY(nsIContent)
|
||
NS_INTERFACE_MAP_ENTRY(nsINode)
|
||
NS_INTERFACE_MAP_ENTRY(nsIDOMEventTarget)
|
||
NS_INTERFACE_MAP_ENTRY(mozilla::dom::EventTarget)
|
||
NS_INTERFACE_MAP_ENTRY_TEAROFF(nsISupportsWeakReference,
|
||
new nsNodeSupportsWeakRefTearoff(this))
|
||
// DOM bindings depend on the identity pointer being the
|
||
// same as nsINode (which nsIContent inherits).
|
||
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
||
NS_INTERFACE_MAP_END
|
||
|
||
NS_IMPL_MAIN_THREAD_ONLY_CYCLE_COLLECTING_ADDREF(nsIContent)
|
||
NS_IMPL_MAIN_THREAD_ONLY_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(nsIContent,
|
||
nsNodeUtils::LastRelease(this))
|
||
|
||
nsIContent*
|
||
nsIContent::FindFirstNonChromeOnlyAccessContent() const
|
||
{
|
||
// This handles also nested native anonymous content.
|
||
for (const nsIContent *content = this; content;
|
||
content = content->GetBindingParent()) {
|
||
if (!content->ChromeOnlyAccess()) {
|
||
// Oops, this function signature allows casting const to
|
||
// non-const. (Then again, so does GetChildAt_Deprecated(0)->GetParent().)
|
||
return const_cast<nsIContent*>(content);
|
||
}
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
// https://dom.spec.whatwg.org/#dom-slotable-assignedslot
|
||
HTMLSlotElement*
|
||
nsIContent::GetAssignedSlotByMode() const
|
||
{
|
||
/**
|
||
* Get slotable's assigned slot for the result of
|
||
* find a slot with open flag UNSET [1].
|
||
*
|
||
* [1] https://dom.spec.whatwg.org/#assign-a-slot
|
||
*/
|
||
HTMLSlotElement* slot = GetAssignedSlot();
|
||
if (!slot) {
|
||
return nullptr;
|
||
}
|
||
|
||
MOZ_ASSERT(GetParent());
|
||
MOZ_ASSERT(GetParent()->GetShadowRoot());
|
||
|
||
/**
|
||
* Additional check for open flag SET:
|
||
* If slotable’s parent’s shadow root's mode is not "open",
|
||
* then return null.
|
||
*/
|
||
if (GetParent()->GetShadowRoot()->IsClosed()) {
|
||
return nullptr;
|
||
}
|
||
|
||
return slot;
|
||
}
|
||
|
||
nsIContent::IMEState
|
||
nsIContent::GetDesiredIMEState()
|
||
{
|
||
if (!IsEditable()) {
|
||
// Check for the special case where we're dealing with elements which don't
|
||
// have the editable flag set, but are readwrite (such as text controls).
|
||
if (!IsElement() ||
|
||
!AsElement()->State().HasState(NS_EVENT_STATE_MOZ_READWRITE)) {
|
||
return IMEState(IMEState::DISABLED);
|
||
}
|
||
}
|
||
// NOTE: The content for independent editors (e.g., input[type=text],
|
||
// textarea) must override this method, so, we don't need to worry about
|
||
// that here.
|
||
nsIContent *editableAncestor = GetEditingHost();
|
||
|
||
// This is in another editable content, use the result of it.
|
||
if (editableAncestor && editableAncestor != this) {
|
||
return editableAncestor->GetDesiredIMEState();
|
||
}
|
||
nsIDocument* doc = GetComposedDoc();
|
||
if (!doc) {
|
||
return IMEState(IMEState::DISABLED);
|
||
}
|
||
nsPresContext* pc = doc->GetPresContext();
|
||
if (!pc) {
|
||
return IMEState(IMEState::DISABLED);
|
||
}
|
||
HTMLEditor* htmlEditor = nsContentUtils::GetHTMLEditor(pc);
|
||
if (!htmlEditor) {
|
||
return IMEState(IMEState::DISABLED);
|
||
}
|
||
IMEState state;
|
||
htmlEditor->GetPreferredIMEState(&state);
|
||
return state;
|
||
}
|
||
|
||
bool
|
||
nsIContent::HasIndependentSelection()
|
||
{
|
||
nsIFrame* frame = GetPrimaryFrame();
|
||
return (frame && frame->GetStateBits() & NS_FRAME_INDEPENDENT_SELECTION);
|
||
}
|
||
|
||
dom::Element*
|
||
nsIContent::GetEditingHost()
|
||
{
|
||
// If this isn't editable, return nullptr.
|
||
if (!IsEditable()) {
|
||
return nullptr;
|
||
}
|
||
|
||
nsIDocument* doc = GetComposedDoc();
|
||
if (!doc) {
|
||
return nullptr;
|
||
}
|
||
|
||
// If this is in designMode, we should return <body>
|
||
if (doc->HasFlag(NODE_IS_EDITABLE) && !IsInShadowTree()) {
|
||
return doc->GetBodyElement();
|
||
}
|
||
|
||
nsIContent* content = this;
|
||
for (dom::Element* parent = GetParentElement();
|
||
parent && parent->HasFlag(NODE_IS_EDITABLE);
|
||
parent = content->GetParentElement()) {
|
||
content = parent;
|
||
}
|
||
return content->AsElement();
|
||
}
|
||
|
||
nsresult
|
||
nsIContent::LookupNamespaceURIInternal(const nsAString& aNamespacePrefix,
|
||
nsAString& aNamespaceURI) const
|
||
{
|
||
if (aNamespacePrefix.EqualsLiteral("xml")) {
|
||
// Special-case for xml prefix
|
||
aNamespaceURI.AssignLiteral("http://www.w3.org/XML/1998/namespace");
|
||
return NS_OK;
|
||
}
|
||
|
||
if (aNamespacePrefix.EqualsLiteral("xmlns")) {
|
||
// Special-case for xmlns prefix
|
||
aNamespaceURI.AssignLiteral("http://www.w3.org/2000/xmlns/");
|
||
return NS_OK;
|
||
}
|
||
|
||
RefPtr<nsAtom> name;
|
||
if (!aNamespacePrefix.IsEmpty()) {
|
||
name = NS_Atomize(aNamespacePrefix);
|
||
NS_ENSURE_TRUE(name, NS_ERROR_OUT_OF_MEMORY);
|
||
}
|
||
else {
|
||
name = nsGkAtoms::xmlns;
|
||
}
|
||
// Trace up the content parent chain looking for the namespace
|
||
// declaration that declares aNamespacePrefix.
|
||
const nsIContent* content = this;
|
||
do {
|
||
if (content->IsElement() &&
|
||
content->AsElement()->GetAttr(kNameSpaceID_XMLNS, name, aNamespaceURI))
|
||
return NS_OK;
|
||
} while ((content = content->GetParent()));
|
||
return NS_ERROR_FAILURE;
|
||
}
|
||
|
||
nsAtom*
|
||
nsIContent::GetLang() const
|
||
{
|
||
for (const auto* content = this; content; content = content->GetParent()) {
|
||
if (!content->IsElement()) {
|
||
continue;
|
||
}
|
||
|
||
auto* element = content->AsElement();
|
||
if (!element->GetAttrCount()) {
|
||
continue;
|
||
}
|
||
|
||
// xml:lang has precedence over lang on HTML elements (see
|
||
// XHTML1 section C.7).
|
||
const nsAttrValue* attr =
|
||
element->GetParsedAttr(nsGkAtoms::lang, kNameSpaceID_XML);
|
||
if (!attr && element->SupportsLangAttr()) {
|
||
attr = element->GetParsedAttr(nsGkAtoms::lang);
|
||
}
|
||
if (attr) {
|
||
MOZ_ASSERT(attr->Type() == nsAttrValue::eAtom);
|
||
MOZ_ASSERT(attr->GetAtomValue());
|
||
return attr->GetAtomValue();
|
||
}
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
already_AddRefed<nsIURI>
|
||
nsIContent::GetBaseURI(bool aTryUseXHRDocBaseURI) const
|
||
{
|
||
if (IsInAnonymousSubtree() && IsAnonymousContentInSVGUseSubtree()) {
|
||
nsIContent* bindingParent = GetBindingParent();
|
||
MOZ_ASSERT(bindingParent);
|
||
SVGUseElement* useElement = static_cast<SVGUseElement*>(bindingParent);
|
||
// XXX Ignore xml:base as we are removing it.
|
||
if (URLExtraData* data = useElement->GetContentURLData()) {
|
||
return do_AddRef(data->BaseURI());
|
||
}
|
||
}
|
||
|
||
nsIDocument* doc = OwnerDoc();
|
||
// Start with document base
|
||
nsCOMPtr<nsIURI> base = doc->GetBaseURI(aTryUseXHRDocBaseURI);
|
||
|
||
// Collect array of xml:base attribute values up the parent chain. This
|
||
// is slightly slower for the case when there are xml:base attributes, but
|
||
// faster for the far more common case of there not being any such
|
||
// attributes.
|
||
// Also check for SVG elements which require special handling
|
||
AutoTArray<nsString, 5> baseAttrs;
|
||
nsString attr;
|
||
const nsIContent *elem = this;
|
||
do {
|
||
// First check for SVG specialness (why is this SVG specific?)
|
||
if (elem->IsSVGElement()) {
|
||
nsIContent* bindingParent = elem->GetBindingParent();
|
||
if (bindingParent) {
|
||
nsXBLBinding* binding = bindingParent->GetXBLBinding();
|
||
if (binding) {
|
||
// XXX sXBL/XBL2 issue
|
||
// If this is an anonymous XBL element use the binding
|
||
// document for the base URI.
|
||
// XXX Will fail with xml:base
|
||
base = binding->PrototypeBinding()->DocURI();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Otherwise check for xml:base attribute
|
||
if (elem->IsElement()) {
|
||
elem->AsElement()->GetAttr(kNameSpaceID_XML, nsGkAtoms::base, attr);
|
||
if (!attr.IsEmpty()) {
|
||
baseAttrs.AppendElement(attr);
|
||
}
|
||
}
|
||
elem = elem->GetParent();
|
||
} while(elem);
|
||
|
||
if (!baseAttrs.IsEmpty()) {
|
||
doc->WarnOnceAbout(nsIDocument::eXMLBaseAttribute);
|
||
// Now resolve against all xml:base attrs
|
||
for (uint32_t i = baseAttrs.Length() - 1; i != uint32_t(-1); --i) {
|
||
nsCOMPtr<nsIURI> newBase;
|
||
nsresult rv = NS_NewURI(getter_AddRefs(newBase), baseAttrs[i],
|
||
doc->GetDocumentCharacterSet(), base);
|
||
// Do a security check, almost the same as nsDocument::SetBaseURL()
|
||
// Only need to do this on the final uri
|
||
if (NS_SUCCEEDED(rv) && i == 0) {
|
||
rv = nsContentUtils::GetSecurityManager()->
|
||
CheckLoadURIWithPrincipal(NodePrincipal(), newBase,
|
||
nsIScriptSecurityManager::STANDARD);
|
||
}
|
||
if (NS_SUCCEEDED(rv)) {
|
||
base.swap(newBase);
|
||
}
|
||
}
|
||
}
|
||
|
||
return base.forget();
|
||
}
|
||
|
||
nsIURI*
|
||
nsIContent::GetBaseURIForStyleAttr() const
|
||
{
|
||
if (IsInAnonymousSubtree() && IsAnonymousContentInSVGUseSubtree()) {
|
||
nsIContent* bindingParent = GetBindingParent();
|
||
MOZ_ASSERT(bindingParent);
|
||
SVGUseElement* useElement = static_cast<SVGUseElement*>(bindingParent);
|
||
if (URLExtraData* data = useElement->GetContentURLData()) {
|
||
return data->BaseURI();
|
||
}
|
||
}
|
||
// This also ignores the case that SVG inside XBL binding.
|
||
// But it is probably fine.
|
||
return OwnerDoc()->GetDocBaseURI();
|
||
}
|
||
|
||
already_AddRefed<URLExtraData>
|
||
nsIContent::GetURLDataForStyleAttr(nsIPrincipal* aSubjectPrincipal) const
|
||
{
|
||
if (IsInAnonymousSubtree() && IsAnonymousContentInSVGUseSubtree()) {
|
||
nsIContent* bindingParent = GetBindingParent();
|
||
MOZ_ASSERT(bindingParent);
|
||
SVGUseElement* useElement = static_cast<SVGUseElement*>(bindingParent);
|
||
if (URLExtraData* data = useElement->GetContentURLData()) {
|
||
return do_AddRef(data);
|
||
}
|
||
}
|
||
if (aSubjectPrincipal && aSubjectPrincipal != NodePrincipal()) {
|
||
// TODO: Cache this?
|
||
return MakeAndAddRef<URLExtraData>(OwnerDoc()->GetDocBaseURI(),
|
||
OwnerDoc()->GetDocumentURI(),
|
||
aSubjectPrincipal);
|
||
}
|
||
// This also ignores the case that SVG inside XBL binding.
|
||
// But it is probably fine.
|
||
return do_AddRef(OwnerDoc()->DefaultStyleAttrURLData());
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
static inline JSObject*
|
||
GetJSObjectChild(nsWrapperCache* aCache)
|
||
{
|
||
return aCache->PreservingWrapper() ? aCache->GetWrapperPreserveColor() : nullptr;
|
||
}
|
||
|
||
static bool
|
||
NeedsScriptTraverse(nsINode* aNode)
|
||
{
|
||
return aNode->PreservingWrapper() && aNode->GetWrapperPreserveColor() &&
|
||
!aNode->HasKnownLiveWrapperAndDoesNotNeedTracing(aNode);
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsAttrChildContentList)
|
||
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsAttrChildContentList)
|
||
|
||
// If nsAttrChildContentList is changed so that any additional fields are
|
||
// traversed by the cycle collector, then CAN_SKIP must be updated to
|
||
// check that the additional fields are null.
|
||
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(nsAttrChildContentList)
|
||
|
||
// nsAttrChildContentList only ever has a single child, its wrapper, so if
|
||
// the wrapper is known-live, the list can't be part of a garbage cycle.
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsAttrChildContentList)
|
||
return tmp->HasKnownLiveWrapper();
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsAttrChildContentList)
|
||
return tmp->HasKnownLiveWrapperAndDoesNotNeedTracing(tmp);
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
|
||
|
||
// CanSkipThis returns false to avoid problems with incomplete unlinking.
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsAttrChildContentList)
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
|
||
|
||
NS_INTERFACE_TABLE_HEAD(nsAttrChildContentList)
|
||
NS_WRAPPERCACHE_INTERFACE_TABLE_ENTRY
|
||
NS_INTERFACE_TABLE(nsAttrChildContentList, nsINodeList, nsIDOMNodeList)
|
||
NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsAttrChildContentList)
|
||
NS_INTERFACE_MAP_END
|
||
|
||
JSObject*
|
||
nsAttrChildContentList::WrapObject(JSContext *cx,
|
||
JS::Handle<JSObject*> aGivenProto)
|
||
{
|
||
return NodeListBinding::Wrap(cx, this, aGivenProto);
|
||
}
|
||
|
||
uint32_t
|
||
nsAttrChildContentList::Length()
|
||
{
|
||
return mNode ? mNode->GetChildCount() : 0;
|
||
}
|
||
|
||
nsIContent*
|
||
nsAttrChildContentList::Item(uint32_t aIndex)
|
||
{
|
||
if (mNode) {
|
||
return mNode->GetChildAt_Deprecated(aIndex);
|
||
}
|
||
|
||
return nullptr;
|
||
}
|
||
|
||
int32_t
|
||
nsAttrChildContentList::IndexOf(nsIContent* aContent)
|
||
{
|
||
if (mNode) {
|
||
return mNode->ComputeIndexOf(aContent);
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
uint32_t
|
||
nsParentNodeChildContentList::Length()
|
||
{
|
||
if (!mIsCacheValid && !ValidateCache()) {
|
||
return 0;
|
||
}
|
||
|
||
MOZ_ASSERT(mIsCacheValid);
|
||
|
||
return mCachedChildArray.Length();
|
||
}
|
||
|
||
nsIContent*
|
||
nsParentNodeChildContentList::Item(uint32_t aIndex)
|
||
{
|
||
if (!mIsCacheValid && !ValidateCache()) {
|
||
return nullptr;
|
||
}
|
||
|
||
MOZ_ASSERT(mIsCacheValid);
|
||
|
||
return mCachedChildArray.SafeElementAt(aIndex, nullptr);
|
||
}
|
||
|
||
int32_t
|
||
nsParentNodeChildContentList::IndexOf(nsIContent* aContent)
|
||
{
|
||
if (!mIsCacheValid && !ValidateCache()) {
|
||
return -1;
|
||
}
|
||
|
||
MOZ_ASSERT(mIsCacheValid);
|
||
|
||
return mCachedChildArray.IndexOf(aContent);
|
||
}
|
||
|
||
bool
|
||
nsParentNodeChildContentList::ValidateCache()
|
||
{
|
||
MOZ_ASSERT(!mIsCacheValid);
|
||
MOZ_ASSERT(mCachedChildArray.IsEmpty());
|
||
|
||
nsINode* parent = GetParentObject();
|
||
if (!parent) {
|
||
return false;
|
||
}
|
||
|
||
for (nsIContent* node = parent->GetFirstChild(); node;
|
||
node = node->GetNextSibling()) {
|
||
mCachedChildArray.AppendElement(node);
|
||
}
|
||
mIsCacheValid = true;
|
||
|
||
return true;
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
nsIHTMLCollection*
|
||
FragmentOrElement::Children()
|
||
{
|
||
nsDOMSlots* slots = DOMSlots();
|
||
|
||
if (!slots->mChildrenList) {
|
||
slots->mChildrenList = new nsContentList(this, kNameSpaceID_Wildcard,
|
||
nsGkAtoms::_asterisk, nsGkAtoms::_asterisk,
|
||
false);
|
||
}
|
||
|
||
return slots->mChildrenList;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
NS_IMPL_CYCLE_COLLECTION(nsNodeSupportsWeakRefTearoff, mNode)
|
||
|
||
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsNodeSupportsWeakRefTearoff)
|
||
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
||
NS_INTERFACE_MAP_END_AGGREGATED(mNode)
|
||
|
||
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsNodeSupportsWeakRefTearoff)
|
||
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsNodeSupportsWeakRefTearoff)
|
||
|
||
NS_IMETHODIMP
|
||
nsNodeSupportsWeakRefTearoff::GetWeakReference(nsIWeakReference** aInstancePtr)
|
||
{
|
||
nsINode::nsSlots* slots = mNode->Slots();
|
||
if (!slots->mWeakReference) {
|
||
slots->mWeakReference = new nsNodeWeakReference(mNode);
|
||
}
|
||
|
||
NS_ADDREF(*aInstancePtr = slots->mWeakReference);
|
||
|
||
return NS_OK;
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
static const size_t MaxDOMSlotSizeAllowed =
|
||
#ifdef HAVE_64BIT_BUILD
|
||
128;
|
||
#else
|
||
64;
|
||
#endif
|
||
|
||
static_assert(sizeof(nsINode::nsSlots) <= MaxDOMSlotSizeAllowed,
|
||
"DOM slots cannot be grown without consideration");
|
||
static_assert(sizeof(FragmentOrElement::nsDOMSlots) <= MaxDOMSlotSizeAllowed,
|
||
"DOM slots cannot be grown without consideration");
|
||
|
||
void
|
||
nsIContent::nsExtendedContentSlots::Unlink()
|
||
{
|
||
mXBLInsertionPoint = nullptr;
|
||
mContainingShadow = nullptr;
|
||
mAssignedSlot = nullptr;
|
||
}
|
||
|
||
void
|
||
nsIContent::nsExtendedContentSlots::Traverse(nsCycleCollectionTraversalCallback& aCb)
|
||
{
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mContainingShadow");
|
||
aCb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIContent*, mContainingShadow));
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mAssignedSlot");
|
||
aCb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIContent*, mAssignedSlot.get()));
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mXBLInsertionPoint");
|
||
aCb.NoteXPCOMChild(mXBLInsertionPoint.get());
|
||
}
|
||
|
||
nsIContent::nsExtendedContentSlots::nsExtendedContentSlots()
|
||
: mBindingParent(nullptr)
|
||
{
|
||
}
|
||
|
||
nsIContent::nsExtendedContentSlots::~nsExtendedContentSlots() = default;
|
||
|
||
FragmentOrElement::nsDOMSlots::nsDOMSlots()
|
||
: nsIContent::nsContentSlots(),
|
||
mDataset(nullptr)
|
||
{
|
||
}
|
||
|
||
FragmentOrElement::nsDOMSlots::~nsDOMSlots()
|
||
{
|
||
if (mAttributeMap) {
|
||
mAttributeMap->DropReference();
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::nsDOMSlots::Traverse(nsCycleCollectionTraversalCallback& aCb)
|
||
{
|
||
nsIContent::nsContentSlots::Traverse(aCb);
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mSlots->mStyle");
|
||
aCb.NoteXPCOMChild(mStyle.get());
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mSlots->mAttributeMap");
|
||
aCb.NoteXPCOMChild(mAttributeMap.get());
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mSlots->mChildrenList");
|
||
aCb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIDOMNodeList*, mChildrenList));
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mSlots->mClassList");
|
||
aCb.NoteXPCOMChild(mClassList.get());
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::nsDOMSlots::Unlink()
|
||
{
|
||
nsIContent::nsContentSlots::Unlink();
|
||
mStyle = nullptr;
|
||
if (mAttributeMap) {
|
||
mAttributeMap->DropReference();
|
||
mAttributeMap = nullptr;
|
||
}
|
||
mChildrenList = nullptr;
|
||
mClassList = nullptr;
|
||
}
|
||
|
||
size_t
|
||
FragmentOrElement::nsDOMSlots::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
|
||
{
|
||
size_t n = aMallocSizeOf(this);
|
||
if (mExtendedSlots) {
|
||
n += aMallocSizeOf(mExtendedSlots.get());
|
||
}
|
||
|
||
if (mAttributeMap) {
|
||
n += mAttributeMap->SizeOfIncludingThis(aMallocSizeOf);
|
||
}
|
||
|
||
// Measurement of the following members may be added later if DMD finds it is
|
||
// worthwhile:
|
||
// - Superclass members (nsINode::nsSlots)
|
||
// - mStyle
|
||
// - mDataSet
|
||
// - mSMILOverrideStyle
|
||
// - mSMILOverrideStyleDeclaration
|
||
// - mChildrenList
|
||
// - mClassList
|
||
|
||
// The following members are not measured:
|
||
// - mBindingParent / mControllers: because they're non-owning
|
||
return n;
|
||
}
|
||
|
||
FragmentOrElement::nsExtendedDOMSlots::nsExtendedDOMSlots() = default;
|
||
|
||
FragmentOrElement::nsExtendedDOMSlots::~nsExtendedDOMSlots()
|
||
{
|
||
RefPtr<nsFrameLoader> frameLoader = do_QueryObject(mFrameLoaderOrOpener);
|
||
if (frameLoader) {
|
||
frameLoader->Destroy();
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::nsExtendedDOMSlots::Unlink()
|
||
{
|
||
nsIContent::nsExtendedContentSlots::Unlink();
|
||
|
||
// Don't clear mXBLBinding, it'll be done in
|
||
// BindingManager::RemovedFromDocument from FragmentOrElement::Unlink.
|
||
mSMILOverrideStyle = nullptr;
|
||
mControllers = nullptr;
|
||
mLabelsList = nullptr;
|
||
mShadowRoot = nullptr;
|
||
if (mCustomElementData) {
|
||
mCustomElementData->Unlink();
|
||
mCustomElementData = nullptr;
|
||
}
|
||
RefPtr<nsFrameLoader> frameLoader = do_QueryObject(mFrameLoaderOrOpener);
|
||
if (frameLoader) {
|
||
frameLoader->Destroy();
|
||
}
|
||
mFrameLoaderOrOpener = nullptr;
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::nsExtendedDOMSlots::Traverse(nsCycleCollectionTraversalCallback& aCb)
|
||
{
|
||
nsIContent::nsExtendedContentSlots::Traverse(aCb);
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mSMILOverrideStyle");
|
||
aCb.NoteXPCOMChild(mSMILOverrideStyle.get());
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mControllers");
|
||
aCb.NoteXPCOMChild(mControllers);
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mLabelsList");
|
||
aCb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIDOMNodeList*, mLabelsList));
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mShadowRoot");
|
||
aCb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIContent*, mShadowRoot));
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mXBLBinding");
|
||
aCb.NoteNativeChild(mXBLBinding,
|
||
NS_CYCLE_COLLECTION_PARTICIPANT(nsXBLBinding));
|
||
|
||
if (mCustomElementData) {
|
||
mCustomElementData->Traverse(aCb);
|
||
}
|
||
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mExtendedSlots->mFrameLoaderOrOpener");
|
||
aCb.NoteXPCOMChild(mFrameLoaderOrOpener);
|
||
}
|
||
|
||
FragmentOrElement::FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
|
||
: nsIContent(aNodeInfo)
|
||
{
|
||
}
|
||
|
||
FragmentOrElement::FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
|
||
: nsIContent(aNodeInfo)
|
||
{
|
||
}
|
||
|
||
FragmentOrElement::~FragmentOrElement()
|
||
{
|
||
NS_PRECONDITION(!IsInUncomposedDoc(),
|
||
"Please remove this from the document properly");
|
||
if (GetParent()) {
|
||
NS_RELEASE(mParent);
|
||
}
|
||
}
|
||
|
||
already_AddRefed<nsINodeList>
|
||
FragmentOrElement::GetChildren(uint32_t aFilter)
|
||
{
|
||
RefPtr<nsSimpleContentList> list = new nsSimpleContentList(this);
|
||
AllChildrenIterator iter(this, aFilter);
|
||
while (nsIContent* kid = iter.GetNextChild()) {
|
||
list->AppendElement(kid);
|
||
}
|
||
|
||
return list.forget();
|
||
}
|
||
|
||
static nsIContent*
|
||
FindChromeAccessOnlySubtreeOwner(nsIContent* aContent)
|
||
{
|
||
if (aContent->ChromeOnlyAccess()) {
|
||
bool chromeAccessOnly = false;
|
||
while (aContent && !chromeAccessOnly) {
|
||
chromeAccessOnly = aContent->IsRootOfChromeAccessOnlySubtree();
|
||
aContent = aContent->GetParent();
|
||
}
|
||
}
|
||
return aContent;
|
||
}
|
||
|
||
already_AddRefed<nsINode>
|
||
FindChromeAccessOnlySubtreeOwner(EventTarget* aTarget)
|
||
{
|
||
nsCOMPtr<nsINode> node = do_QueryInterface(aTarget);
|
||
if (!node || !node->ChromeOnlyAccess()) {
|
||
return node.forget();
|
||
}
|
||
|
||
if (!node->IsContent()) {
|
||
return nullptr;
|
||
}
|
||
|
||
node = FindChromeAccessOnlySubtreeOwner(node->AsContent());
|
||
return node.forget();
|
||
}
|
||
|
||
void
|
||
nsIContent::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
||
{
|
||
//FIXME! Document how this event retargeting works, Bug 329124.
|
||
aVisitor.mCanHandle = true;
|
||
aVisitor.mMayHaveListenerManager = HasListenerManager();
|
||
|
||
// Don't propagate mouseover and mouseout events when mouse is moving
|
||
// inside chrome access only content.
|
||
bool isAnonForEvents = IsRootOfChromeAccessOnlySubtree();
|
||
aVisitor.mRootOfClosedTree = isAnonForEvents;
|
||
if ((aVisitor.mEvent->mMessage == eMouseOver ||
|
||
aVisitor.mEvent->mMessage == eMouseOut ||
|
||
aVisitor.mEvent->mMessage == ePointerOver ||
|
||
aVisitor.mEvent->mMessage == ePointerOut) &&
|
||
// Check if we should stop event propagation when event has just been
|
||
// dispatched or when we're about to propagate from
|
||
// chrome access only subtree or if we are about to propagate out of
|
||
// a shadow root to a shadow root host.
|
||
((this == aVisitor.mEvent->mOriginalTarget &&
|
||
!ChromeOnlyAccess()) || isAnonForEvents)) {
|
||
nsCOMPtr<nsIContent> relatedTarget =
|
||
do_QueryInterface(aVisitor.mEvent->AsMouseEvent()->mRelatedTarget);
|
||
if (relatedTarget &&
|
||
relatedTarget->OwnerDoc() == OwnerDoc()) {
|
||
|
||
// If current target is anonymous for events or we know that related
|
||
// target is descendant of an element which is anonymous for events,
|
||
// we may want to stop event propagation.
|
||
// If this is the original target, aVisitor.mRelatedTargetIsInAnon
|
||
// must be updated.
|
||
if (isAnonForEvents || aVisitor.mRelatedTargetIsInAnon ||
|
||
(aVisitor.mEvent->mOriginalTarget == this &&
|
||
(aVisitor.mRelatedTargetIsInAnon =
|
||
relatedTarget->ChromeOnlyAccess()))) {
|
||
nsIContent* anonOwner = FindChromeAccessOnlySubtreeOwner(this);
|
||
if (anonOwner) {
|
||
nsIContent* anonOwnerRelated =
|
||
FindChromeAccessOnlySubtreeOwner(relatedTarget);
|
||
if (anonOwnerRelated) {
|
||
// Note, anonOwnerRelated may still be inside some other
|
||
// native anonymous subtree. The case where anonOwner is still
|
||
// inside native anonymous subtree will be handled when event
|
||
// propagates up in the DOM tree.
|
||
while (anonOwner != anonOwnerRelated &&
|
||
anonOwnerRelated->ChromeOnlyAccess()) {
|
||
anonOwnerRelated = FindChromeAccessOnlySubtreeOwner(anonOwnerRelated);
|
||
}
|
||
if (anonOwner == anonOwnerRelated) {
|
||
#ifdef DEBUG_smaug
|
||
nsCOMPtr<nsIContent> originalTarget =
|
||
do_QueryInterface(aVisitor.mEvent->mOriginalTarget);
|
||
nsAutoString ot, ct, rt;
|
||
if (originalTarget) {
|
||
originalTarget->NodeInfo()->NameAtom()->ToString(ot);
|
||
}
|
||
NodeInfo()->NameAtom()->ToString(ct);
|
||
relatedTarget->NodeInfo()->NameAtom()->ToString(rt);
|
||
printf("Stopping %s propagation:"
|
||
"\n\toriginalTarget=%s \n\tcurrentTarget=%s %s"
|
||
"\n\trelatedTarget=%s %s \n%s",
|
||
(aVisitor.mEvent->mMessage == eMouseOver)
|
||
? "mouseover" : "mouseout",
|
||
NS_ConvertUTF16toUTF8(ot).get(),
|
||
NS_ConvertUTF16toUTF8(ct).get(),
|
||
isAnonForEvents
|
||
? "(is native anonymous)"
|
||
: (ChromeOnlyAccess()
|
||
? "(is in native anonymous subtree)" : ""),
|
||
NS_ConvertUTF16toUTF8(rt).get(),
|
||
relatedTarget->ChromeOnlyAccess()
|
||
? "(is in native anonymous subtree)" : "",
|
||
(originalTarget &&
|
||
relatedTarget->FindFirstNonChromeOnlyAccessContent() ==
|
||
originalTarget->FindFirstNonChromeOnlyAccessContent())
|
||
? "" : "Wrong event propagation!?!\n");
|
||
#endif
|
||
aVisitor.SetParentTarget(nullptr, false);
|
||
// Event should not propagate to non-anon content.
|
||
aVisitor.mCanHandle = isAnonForEvents;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Event parent is the assigned slot, if node is assigned, or node's parent
|
||
// otherwise.
|
||
HTMLSlotElement* slot = GetAssignedSlot();
|
||
nsIContent* parent = slot ? slot : GetParent();
|
||
|
||
// Event may need to be retargeted if this is the root of a native
|
||
// anonymous content subtree or event is dispatched somewhere inside XBL.
|
||
if (isAnonForEvents) {
|
||
#ifdef DEBUG
|
||
// If a DOM event is explicitly dispatched using node.dispatchEvent(), then
|
||
// all the events are allowed even in the native anonymous content..
|
||
nsCOMPtr<nsIContent> t =
|
||
do_QueryInterface(aVisitor.mEvent->mOriginalTarget);
|
||
NS_ASSERTION(!t || !t->ChromeOnlyAccess() ||
|
||
aVisitor.mEvent->mClass != eMutationEventClass ||
|
||
aVisitor.mDOMEvent,
|
||
"Mutation event dispatched in native anonymous content!?!");
|
||
#endif
|
||
aVisitor.mEventTargetAtParent = parent;
|
||
} else if (parent && aVisitor.mOriginalTargetIsInAnon) {
|
||
nsCOMPtr<nsIContent> content(do_QueryInterface(aVisitor.mEvent->mTarget));
|
||
if (content && content->GetBindingParent() == parent) {
|
||
aVisitor.mEventTargetAtParent = parent;
|
||
}
|
||
}
|
||
|
||
// check for an anonymous parent
|
||
// XXX XBL2/sXBL issue
|
||
if (HasFlag(NODE_MAY_BE_IN_BINDING_MNGR)) {
|
||
nsIContent* insertionParent = GetXBLInsertionParent();
|
||
NS_ASSERTION(!(aVisitor.mEventTargetAtParent && insertionParent &&
|
||
aVisitor.mEventTargetAtParent != insertionParent),
|
||
"Retargeting and having insertion parent!");
|
||
if (insertionParent) {
|
||
parent = insertionParent;
|
||
}
|
||
}
|
||
|
||
if (!aVisitor.mEvent->mFlags.mComposedInNativeAnonymousContent &&
|
||
IsRootOfNativeAnonymousSubtree() && OwnerDoc()->GetWindow()) {
|
||
aVisitor.SetParentTarget(OwnerDoc()->GetWindow()->GetParentTarget(), true);
|
||
} else if (parent) {
|
||
aVisitor.SetParentTarget(parent, false);
|
||
if (slot) {
|
||
ShadowRoot* root = slot->GetContainingShadow();
|
||
if (root && root->IsClosed()) {
|
||
aVisitor.mParentIsSlotInClosedTree = true;
|
||
}
|
||
}
|
||
} else {
|
||
aVisitor.SetParentTarget(GetComposedDoc(), false);
|
||
}
|
||
|
||
if (!ChromeOnlyAccess() && !aVisitor.mRelatedTargetRetargetedInCurrentScope) {
|
||
// We don't support Shadow DOM in native anonymous content yet.
|
||
aVisitor.mRelatedTargetRetargetedInCurrentScope = true;
|
||
if (aVisitor.mEvent->mOriginalRelatedTarget) {
|
||
// https://dom.spec.whatwg.org/#concept-event-dispatch
|
||
// Step 3.
|
||
// "Let relatedTarget be the result of retargeting event's relatedTarget
|
||
// against target if event's relatedTarget is non-null, and null
|
||
// otherwise."
|
||
//
|
||
// This is a bit complicated because the event might be from native
|
||
// anonymous content, but we need to deal with non-native anonymous
|
||
// content there.
|
||
bool initialTarget = this == aVisitor.mEvent->mOriginalTarget;
|
||
nsCOMPtr<nsINode> originalTargetAsNode;
|
||
// Use of mOriginalTargetIsInAnon is an optimization here.
|
||
if (!initialTarget && aVisitor.mOriginalTargetIsInAnon) {
|
||
originalTargetAsNode =
|
||
FindChromeAccessOnlySubtreeOwner(aVisitor.mEvent->mOriginalTarget);
|
||
initialTarget = originalTargetAsNode == this;
|
||
}
|
||
if (initialTarget) {
|
||
nsCOMPtr<nsINode> relatedTargetAsNode =
|
||
FindChromeAccessOnlySubtreeOwner(aVisitor.mEvent->mOriginalRelatedTarget);
|
||
if (!originalTargetAsNode) {
|
||
originalTargetAsNode =
|
||
do_QueryInterface(aVisitor.mEvent->mOriginalTarget);
|
||
}
|
||
|
||
if (relatedTargetAsNode && originalTargetAsNode) {
|
||
nsINode* retargetedRelatedTarget =
|
||
nsContentUtils::Retarget(relatedTargetAsNode, originalTargetAsNode);
|
||
if (originalTargetAsNode == retargetedRelatedTarget &&
|
||
retargetedRelatedTarget != relatedTargetAsNode) {
|
||
// Step 4.
|
||
// "If target is relatedTarget and target is not event's
|
||
// relatedTarget, then return true."
|
||
aVisitor.IgnoreCurrentTarget();
|
||
// Old code relies on mTarget to point to the first element which
|
||
// was not added to the event target chain because of mCanHandle
|
||
// being false, but in Shadow DOM case mTarget really should
|
||
// point to a node in Shadow DOM.
|
||
aVisitor.mEvent->mTarget = aVisitor.mTargetInKnownToBeHandledScope;
|
||
return;
|
||
}
|
||
|
||
// Part of step 5. Retargeting target has happened already higher
|
||
// up in this method.
|
||
// "Append to an event path with event, target, targetOverride,
|
||
// relatedTarget, and false."
|
||
aVisitor.mRetargetedRelatedTarget = retargetedRelatedTarget;
|
||
}
|
||
} else {
|
||
nsCOMPtr<nsINode> relatedTargetAsNode =
|
||
FindChromeAccessOnlySubtreeOwner(aVisitor.mEvent->mOriginalRelatedTarget);
|
||
if (relatedTargetAsNode) {
|
||
// Step 11.3.
|
||
// "Let relatedTarget be the result of retargeting event's
|
||
// relatedTarget against parent if event's relatedTarget is non-null,
|
||
// and null otherwise.".
|
||
nsINode* retargetedRelatedTarget =
|
||
nsContentUtils::Retarget(relatedTargetAsNode, this);
|
||
nsCOMPtr<nsINode> targetInKnownToBeHandledScope =
|
||
FindChromeAccessOnlySubtreeOwner(aVisitor.mTargetInKnownToBeHandledScope);
|
||
// If aVisitor.mTargetInKnownToBeHandledScope wasn't nsINode,
|
||
// targetInKnownToBeHandledScope will be null. This may happen when
|
||
// dispatching event to Window object in a content page and
|
||
// propagating the event to a chrome Element.
|
||
if (targetInKnownToBeHandledScope &&
|
||
nsContentUtils::ContentIsShadowIncludingDescendantOf(
|
||
this, targetInKnownToBeHandledScope->SubtreeRoot())) {
|
||
// Part of step 11.4.
|
||
// "If target's root is a shadow-including inclusive ancestor of
|
||
// parent, then"
|
||
// "...Append to an event path with event, parent, null, relatedTarget,
|
||
// " and slot-in-closed-tree."
|
||
aVisitor.mRetargetedRelatedTarget = retargetedRelatedTarget;
|
||
} else if (this == retargetedRelatedTarget) {
|
||
// Step 11.5
|
||
// "Otherwise, if parent and relatedTarget are identical, then set
|
||
// parent to null."
|
||
aVisitor.IgnoreCurrentTarget();
|
||
// Old code relies on mTarget to point to the first element which
|
||
// was not added to the event target chain because of mCanHandle
|
||
// being false, but in Shadow DOM case mTarget really should
|
||
// point to a node in Shadow DOM.
|
||
aVisitor.mEvent->mTarget = aVisitor.mTargetInKnownToBeHandledScope;
|
||
return;
|
||
} else {
|
||
// Step 11.6
|
||
aVisitor.mRetargetedRelatedTarget = retargetedRelatedTarget;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (slot) {
|
||
// Inform that we're about to exit the current scope.
|
||
aVisitor.mRelatedTargetRetargetedInCurrentScope = false;
|
||
}
|
||
}
|
||
|
||
bool
|
||
nsIContent::IsFocusable(int32_t* aTabIndex, bool aWithMouse)
|
||
{
|
||
bool focusable = IsFocusableInternal(aTabIndex, aWithMouse);
|
||
// Ensure that the return value and aTabIndex are consistent in the case
|
||
// we're in userfocusignored context.
|
||
if (focusable || (aTabIndex && *aTabIndex != -1)) {
|
||
if (nsContentUtils::IsUserFocusIgnored(this)) {
|
||
if (aTabIndex) {
|
||
*aTabIndex = -1;
|
||
}
|
||
return false;
|
||
}
|
||
return focusable;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool
|
||
nsIContent::IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse)
|
||
{
|
||
if (aTabIndex) {
|
||
*aTabIndex = -1; // Default, not tabbable
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool
|
||
FragmentOrElement::IsLink(nsIURI** aURI) const
|
||
{
|
||
*aURI = nullptr;
|
||
return false;
|
||
}
|
||
|
||
nsXBLBinding*
|
||
FragmentOrElement::DoGetXBLBinding() const
|
||
{
|
||
MOZ_ASSERT(HasFlag(NODE_MAY_BE_IN_BINDING_MNGR));
|
||
const nsExtendedDOMSlots* slots = GetExistingExtendedDOMSlots();
|
||
return slots ? slots->mXBLBinding.get() : nullptr;
|
||
}
|
||
|
||
nsIContent*
|
||
nsIContent::GetContainingShadowHost() const
|
||
{
|
||
if (mozilla::dom::ShadowRoot* shadow = GetContainingShadow()) {
|
||
return shadow->GetHost();
|
||
}
|
||
return nullptr;
|
||
}
|
||
|
||
void
|
||
nsIContent::SetAssignedSlot(HTMLSlotElement* aSlot)
|
||
{
|
||
MOZ_ASSERT(aSlot || GetExistingExtendedContentSlots());
|
||
ExtendedContentSlots()->mAssignedSlot = aSlot;
|
||
}
|
||
|
||
void
|
||
nsIContent::SetXBLInsertionPoint(nsIContent* aContent)
|
||
{
|
||
if (aContent) {
|
||
nsExtendedContentSlots* slots = ExtendedContentSlots();
|
||
SetFlags(NODE_MAY_BE_IN_BINDING_MNGR);
|
||
slots->mXBLInsertionPoint = aContent;
|
||
} else {
|
||
if (nsExtendedContentSlots* slots = GetExistingExtendedContentSlots()) {
|
||
slots->mXBLInsertionPoint = nullptr;
|
||
}
|
||
}
|
||
}
|
||
|
||
nsresult
|
||
FragmentOrElement::InsertChildBefore(nsIContent* aKid,
|
||
nsIContent* aBeforeThis,
|
||
bool aNotify)
|
||
{
|
||
NS_PRECONDITION(aKid, "null ptr");
|
||
|
||
int32_t index = aBeforeThis ? ComputeIndexOf(aBeforeThis) : GetChildCount();
|
||
MOZ_ASSERT(index >= 0);
|
||
|
||
return doInsertChildAt(aKid, index, aNotify, mAttrsAndChildren);
|
||
}
|
||
|
||
nsresult
|
||
FragmentOrElement::InsertChildAt_Deprecated(nsIContent* aKid,
|
||
uint32_t aIndex,
|
||
bool aNotify)
|
||
{
|
||
NS_PRECONDITION(aKid, "null ptr");
|
||
|
||
return doInsertChildAt(aKid, aIndex, aNotify, mAttrsAndChildren);
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::RemoveChildAt_Deprecated(uint32_t aIndex, bool aNotify)
|
||
{
|
||
nsCOMPtr<nsIContent> oldKid = mAttrsAndChildren.GetSafeChildAt(aIndex);
|
||
NS_ASSERTION(oldKid == GetChildAt_Deprecated(aIndex), "Unexpected child in RemoveChildAt_Deprecated");
|
||
|
||
if (oldKid) {
|
||
doRemoveChildAt(aIndex, aNotify, oldKid, mAttrsAndChildren);
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::RemoveChildNode(nsIContent* aKid, bool aNotify)
|
||
{
|
||
// Let's keep the node alive.
|
||
nsCOMPtr<nsIContent> kungFuDeathGrip = aKid;
|
||
doRemoveChildAt(ComputeIndexOf(aKid), aNotify, aKid, mAttrsAndChildren);
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::GetTextContentInternal(nsAString& aTextContent,
|
||
OOMReporter& aError)
|
||
{
|
||
if (!nsContentUtils::GetNodeTextContent(this, true, aTextContent, fallible)) {
|
||
aError.ReportOOM();
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::SetTextContentInternal(const nsAString& aTextContent,
|
||
nsIPrincipal* aSubjectPrincipal,
|
||
ErrorResult& aError)
|
||
{
|
||
aError = nsContentUtils::SetNodeTextContent(this, aTextContent, false);
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::DestroyContent()
|
||
{
|
||
nsIDocument* document = OwnerDoc();
|
||
|
||
// Drop any servo data. We do this before the RemovedFromDocument call below
|
||
// so that it doesn't need to try to keep the style state sane when shuffling
|
||
// around the flattened tree.
|
||
//
|
||
// TODO(emilio): I suspect this can be asserted against instead, with a bit of
|
||
// effort to avoid calling nsDocument::Destroy with a shell...
|
||
if (IsElement()) {
|
||
AsElement()->ClearServoData();
|
||
}
|
||
|
||
document->BindingManager()->RemovedFromDocument(this, document,
|
||
nsBindingManager::eRunDtor);
|
||
document->ClearBoxObjectFor(this);
|
||
|
||
uint32_t i, count = mAttrsAndChildren.ChildCount();
|
||
for (i = 0; i < count; ++i) {
|
||
// The child can remove itself from the parent in BindToTree.
|
||
mAttrsAndChildren.ChildAt(i)->DestroyContent();
|
||
}
|
||
ShadowRoot* shadowRoot = GetShadowRoot();
|
||
if (shadowRoot) {
|
||
shadowRoot->DestroyContent();
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::SaveSubtreeState()
|
||
{
|
||
uint32_t i, count = mAttrsAndChildren.ChildCount();
|
||
for (i = 0; i < count; ++i) {
|
||
mAttrsAndChildren.ChildAt(i)->SaveSubtreeState();
|
||
}
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
// Generic DOMNode implementations
|
||
|
||
void
|
||
FragmentOrElement::FireNodeInserted(nsIDocument* aDoc,
|
||
nsINode* aParent,
|
||
nsTArray<nsCOMPtr<nsIContent> >& aNodes)
|
||
{
|
||
uint32_t count = aNodes.Length();
|
||
for (uint32_t i = 0; i < count; ++i) {
|
||
nsIContent* childContent = aNodes[i];
|
||
|
||
if (nsContentUtils::HasMutationListeners(childContent,
|
||
NS_EVENT_BITS_MUTATION_NODEINSERTED, aParent)) {
|
||
InternalMutationEvent mutation(true, eLegacyNodeInserted);
|
||
mutation.mRelatedNode = do_QueryInterface(aParent);
|
||
|
||
mozAutoSubtreeModified subtree(aDoc, aParent);
|
||
(new AsyncEventDispatcher(childContent, mutation))->RunDOMEventWhenSafe();
|
||
}
|
||
}
|
||
}
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
// nsISupports implementation
|
||
|
||
#define SUBTREE_UNBINDINGS_PER_RUNNABLE 500
|
||
|
||
class ContentUnbinder : public Runnable
|
||
{
|
||
public:
|
||
ContentUnbinder()
|
||
: Runnable("ContentUnbinder")
|
||
{
|
||
mLast = this;
|
||
}
|
||
|
||
~ContentUnbinder()
|
||
{
|
||
Run();
|
||
}
|
||
|
||
void UnbindSubtree(nsIContent* aNode)
|
||
{
|
||
if (aNode->NodeType() != nsINode::ELEMENT_NODE &&
|
||
aNode->NodeType() != nsINode::DOCUMENT_FRAGMENT_NODE) {
|
||
return;
|
||
}
|
||
FragmentOrElement* container = static_cast<FragmentOrElement*>(aNode);
|
||
uint32_t childCount = container->mAttrsAndChildren.ChildCount();
|
||
if (childCount) {
|
||
// Invalidate cached array of child nodes
|
||
container->InvalidateChildNodes();
|
||
|
||
while (childCount-- > 0) {
|
||
// Hold a strong ref to the node when we remove it, because we may be
|
||
// the last reference to it. We need to call TakeChildAt() and
|
||
// update mFirstChild before calling UnbindFromTree, since this last
|
||
// can notify various observers and they should really see consistent
|
||
// tree state.
|
||
// If this code changes, change the corresponding code in
|
||
// FragmentOrElement's and nsDocument's unlink impls.
|
||
nsCOMPtr<nsIContent> child =
|
||
container->mAttrsAndChildren.TakeChildAt(childCount);
|
||
if (childCount == 0) {
|
||
container->mFirstChild = nullptr;
|
||
}
|
||
UnbindSubtree(child);
|
||
child->UnbindFromTree();
|
||
}
|
||
}
|
||
}
|
||
|
||
NS_IMETHOD Run() override
|
||
{
|
||
nsAutoScriptBlocker scriptBlocker;
|
||
uint32_t len = mSubtreeRoots.Length();
|
||
if (len) {
|
||
for (uint32_t i = 0; i < len; ++i) {
|
||
UnbindSubtree(mSubtreeRoots[i]);
|
||
}
|
||
mSubtreeRoots.Clear();
|
||
}
|
||
nsCycleCollector_dispatchDeferredDeletion();
|
||
if (this == sContentUnbinder) {
|
||
sContentUnbinder = nullptr;
|
||
if (mNext) {
|
||
RefPtr<ContentUnbinder> next;
|
||
next.swap(mNext);
|
||
sContentUnbinder = next;
|
||
next->mLast = mLast;
|
||
mLast = nullptr;
|
||
NS_IdleDispatchToCurrentThread(next.forget());
|
||
}
|
||
}
|
||
return NS_OK;
|
||
}
|
||
|
||
static void UnbindAll()
|
||
{
|
||
RefPtr<ContentUnbinder> ub = sContentUnbinder;
|
||
sContentUnbinder = nullptr;
|
||
while (ub) {
|
||
ub->Run();
|
||
ub = ub->mNext;
|
||
}
|
||
}
|
||
|
||
static void Append(nsIContent* aSubtreeRoot)
|
||
{
|
||
if (!sContentUnbinder) {
|
||
sContentUnbinder = new ContentUnbinder();
|
||
nsCOMPtr<nsIRunnable> e = sContentUnbinder;
|
||
NS_IdleDispatchToCurrentThread(e.forget());
|
||
}
|
||
|
||
if (sContentUnbinder->mLast->mSubtreeRoots.Length() >=
|
||
SUBTREE_UNBINDINGS_PER_RUNNABLE) {
|
||
sContentUnbinder->mLast->mNext = new ContentUnbinder();
|
||
sContentUnbinder->mLast = sContentUnbinder->mLast->mNext;
|
||
}
|
||
sContentUnbinder->mLast->mSubtreeRoots.AppendElement(aSubtreeRoot);
|
||
}
|
||
|
||
private:
|
||
AutoTArray<nsCOMPtr<nsIContent>,
|
||
SUBTREE_UNBINDINGS_PER_RUNNABLE> mSubtreeRoots;
|
||
RefPtr<ContentUnbinder> mNext;
|
||
ContentUnbinder* mLast;
|
||
static ContentUnbinder* sContentUnbinder;
|
||
};
|
||
|
||
ContentUnbinder* ContentUnbinder::sContentUnbinder = nullptr;
|
||
|
||
void
|
||
FragmentOrElement::ClearContentUnbinder()
|
||
{
|
||
ContentUnbinder::UnbindAll();
|
||
}
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CLASS(FragmentOrElement)
|
||
|
||
// We purposefully don't UNLINK_BEGIN_INHERITED here.
|
||
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(FragmentOrElement)
|
||
nsIContent::Unlink(tmp);
|
||
|
||
// The XBL binding is removed by RemoveFromBindingManagerRunnable
|
||
// which is dispatched in UnbindFromTree.
|
||
|
||
if (tmp->HasProperties()) {
|
||
if (tmp->IsElement()) {
|
||
Element* elem = tmp->AsElement();
|
||
elem->UnlinkIntersectionObservers();
|
||
}
|
||
|
||
if (tmp->IsHTMLElement() || tmp->IsSVGElement()) {
|
||
nsStaticAtom*** props = Element::HTMLSVGPropertiesToTraverseAndUnlink();
|
||
for (uint32_t i = 0; props[i]; ++i) {
|
||
tmp->DeleteProperty(*props[i]);
|
||
}
|
||
if (tmp->MayHaveAnimations()) {
|
||
nsAtom** effectProps = EffectSet::GetEffectSetPropertyAtoms();
|
||
for (uint32_t i = 0; effectProps[i]; ++i) {
|
||
tmp->DeleteProperty(effectProps[i]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Unlink child content (and unbind our subtree).
|
||
if (tmp->UnoptimizableCCNode() || !nsCCUncollectableMarker::sGeneration) {
|
||
uint32_t childCount = tmp->mAttrsAndChildren.ChildCount();
|
||
if (childCount) {
|
||
// Don't allow script to run while we're unbinding everything.
|
||
nsAutoScriptBlocker scriptBlocker;
|
||
while (childCount-- > 0) {
|
||
// Hold a strong ref to the node when we remove it, because we may be
|
||
// the last reference to it. We need to call TakeChildAt() and
|
||
// update mFirstChild before calling UnbindFromTree, since this last
|
||
// can notify various observers and they should really see consistent
|
||
// tree state.
|
||
// If this code changes, change the corresponding code in nsDocument's
|
||
// unlink impl and ContentUnbinder::UnbindSubtree.
|
||
nsCOMPtr<nsIContent> child = tmp->mAttrsAndChildren.TakeChildAt(childCount);
|
||
if (childCount == 0) {
|
||
tmp->mFirstChild = nullptr;
|
||
}
|
||
child->UnbindFromTree();
|
||
}
|
||
}
|
||
} else if (!tmp->GetParent() && tmp->mAttrsAndChildren.ChildCount()) {
|
||
ContentUnbinder::Append(tmp);
|
||
} /* else {
|
||
The subtree root will end up to a ContentUnbinder, and that will
|
||
unbind the child nodes.
|
||
} */
|
||
|
||
// Clear flag here because unlinking slots will clear the
|
||
// containing shadow root pointer.
|
||
tmp->UnsetFlags(NODE_IS_IN_SHADOW_TREE);
|
||
|
||
nsIDocument* doc = tmp->OwnerDoc();
|
||
doc->BindingManager()->RemovedFromDocument(tmp, doc,
|
||
nsBindingManager::eDoNotRunDtor);
|
||
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(FragmentOrElement)
|
||
|
||
void
|
||
FragmentOrElement::MarkNodeChildren(nsINode* aNode)
|
||
{
|
||
JSObject* o = GetJSObjectChild(aNode);
|
||
if (o) {
|
||
JS::ExposeObjectToActiveJS(o);
|
||
}
|
||
|
||
EventListenerManager* elm = aNode->GetExistingListenerManager();
|
||
if (elm) {
|
||
elm->MarkForCC();
|
||
}
|
||
}
|
||
|
||
nsINode*
|
||
FindOptimizableSubtreeRoot(nsINode* aNode)
|
||
{
|
||
nsINode* p;
|
||
while ((p = aNode->GetParentNode())) {
|
||
if (aNode->UnoptimizableCCNode()) {
|
||
return nullptr;
|
||
}
|
||
aNode = p;
|
||
}
|
||
|
||
if (aNode->UnoptimizableCCNode()) {
|
||
return nullptr;
|
||
}
|
||
return aNode;
|
||
}
|
||
|
||
StaticAutoPtr<nsTHashtable<nsPtrHashKey<nsINode>>> gCCBlackMarkedNodes;
|
||
|
||
static void
|
||
ClearBlackMarkedNodes()
|
||
{
|
||
if (!gCCBlackMarkedNodes) {
|
||
return;
|
||
}
|
||
for (auto iter = gCCBlackMarkedNodes->ConstIter(); !iter.Done();
|
||
iter.Next()) {
|
||
nsINode* n = iter.Get()->GetKey();
|
||
n->SetCCMarkedRoot(false);
|
||
n->SetInCCBlackTree(false);
|
||
}
|
||
gCCBlackMarkedNodes = nullptr;
|
||
}
|
||
|
||
// static
|
||
void
|
||
FragmentOrElement::RemoveBlackMarkedNode(nsINode* aNode)
|
||
{
|
||
if (!gCCBlackMarkedNodes) {
|
||
return;
|
||
}
|
||
gCCBlackMarkedNodes->RemoveEntry(aNode);
|
||
}
|
||
|
||
static bool
|
||
IsCertainlyAliveNode(nsINode* aNode, nsIDocument* aDoc)
|
||
{
|
||
MOZ_ASSERT(aNode->GetUncomposedDoc() == aDoc);
|
||
|
||
// Marked to be in-CC-generation or if the document is an svg image that's
|
||
// being kept alive by the image cache. (Note that an svg image's internal
|
||
// SVG document will receive an OnPageHide() call when it gets purged from
|
||
// the image cache; hence, we use IsVisible() as a hint that the document is
|
||
// actively being kept alive by the cache.)
|
||
return nsCCUncollectableMarker::InGeneration(aDoc->GetMarkedCCGeneration()) ||
|
||
(nsCCUncollectableMarker::sGeneration &&
|
||
aDoc->IsBeingUsedAsImage() &&
|
||
aDoc->IsVisible());
|
||
}
|
||
|
||
// static
|
||
bool
|
||
FragmentOrElement::CanSkipInCC(nsINode* aNode)
|
||
{
|
||
// Don't try to optimize anything during shutdown.
|
||
if (nsCCUncollectableMarker::sGeneration == 0) {
|
||
return false;
|
||
}
|
||
|
||
//XXXsmaug Need to figure out in which cases Shadow DOM can be optimized out
|
||
// from the CC graph.
|
||
nsIDocument* currentDoc = aNode->GetUncomposedDoc();
|
||
if (currentDoc && IsCertainlyAliveNode(aNode, currentDoc)) {
|
||
return !NeedsScriptTraverse(aNode);
|
||
}
|
||
|
||
// Bail out early if aNode is somewhere in anonymous content,
|
||
// or otherwise unusual.
|
||
if (aNode->UnoptimizableCCNode()) {
|
||
return false;
|
||
}
|
||
|
||
nsINode* root =
|
||
currentDoc ? static_cast<nsINode*>(currentDoc) :
|
||
FindOptimizableSubtreeRoot(aNode);
|
||
if (!root) {
|
||
return false;
|
||
}
|
||
|
||
// Subtree has been traversed already.
|
||
if (root->CCMarkedRoot()) {
|
||
return root->InCCBlackTree() && !NeedsScriptTraverse(aNode);
|
||
}
|
||
|
||
if (!gCCBlackMarkedNodes) {
|
||
gCCBlackMarkedNodes = new nsTHashtable<nsPtrHashKey<nsINode> >(1020);
|
||
}
|
||
|
||
// nodesToUnpurple contains nodes which will be removed
|
||
// from the purple buffer if the DOM tree is known-live.
|
||
AutoTArray<nsIContent*, 1020> nodesToUnpurple;
|
||
// grayNodes need script traverse, so they aren't removed from
|
||
// the purple buffer, but are marked to be in known-live subtree so that
|
||
// traverse is faster.
|
||
AutoTArray<nsINode*, 1020> grayNodes;
|
||
|
||
bool foundLiveWrapper = root->HasKnownLiveWrapper();
|
||
if (root != currentDoc) {
|
||
currentDoc = nullptr;
|
||
if (NeedsScriptTraverse(root)) {
|
||
grayNodes.AppendElement(root);
|
||
} else if (static_cast<nsIContent*>(root)->IsPurple()) {
|
||
nodesToUnpurple.AppendElement(static_cast<nsIContent*>(root));
|
||
}
|
||
}
|
||
|
||
// Traverse the subtree and check if we could know without CC
|
||
// that it is known-live.
|
||
// Note, this traverse is non-virtual and inline, so it should be a lot faster
|
||
// than CC's generic traverse.
|
||
for (nsIContent* node = root->GetFirstChild(); node;
|
||
node = node->GetNextNode(root)) {
|
||
foundLiveWrapper = foundLiveWrapper || node->HasKnownLiveWrapper();
|
||
if (foundLiveWrapper && currentDoc) {
|
||
// If we can mark the whole document known-live, no need to optimize
|
||
// so much, since when the next purple node in the document will be
|
||
// handled, it is fast to check that currentDoc is in CCGeneration.
|
||
break;
|
||
}
|
||
if (NeedsScriptTraverse(node)) {
|
||
// Gray nodes need real CC traverse.
|
||
grayNodes.AppendElement(node);
|
||
} else if (node->IsPurple()) {
|
||
nodesToUnpurple.AppendElement(node);
|
||
}
|
||
}
|
||
|
||
root->SetCCMarkedRoot(true);
|
||
root->SetInCCBlackTree(foundLiveWrapper);
|
||
gCCBlackMarkedNodes->PutEntry(root);
|
||
|
||
if (!foundLiveWrapper) {
|
||
return false;
|
||
}
|
||
|
||
if (currentDoc) {
|
||
// Special case documents. If we know the document is known-live,
|
||
// we can mark the document to be in CCGeneration.
|
||
currentDoc->
|
||
MarkUncollectableForCCGeneration(nsCCUncollectableMarker::sGeneration);
|
||
} else {
|
||
for (uint32_t i = 0; i < grayNodes.Length(); ++i) {
|
||
nsINode* node = grayNodes[i];
|
||
node->SetInCCBlackTree(true);
|
||
gCCBlackMarkedNodes->PutEntry(node);
|
||
}
|
||
}
|
||
|
||
// Subtree is known-live, we can remove non-gray purple nodes from
|
||
// purple buffer.
|
||
for (uint32_t i = 0; i < nodesToUnpurple.Length(); ++i) {
|
||
nsIContent* purple = nodesToUnpurple[i];
|
||
// Can't remove currently handled purple node.
|
||
if (purple != aNode) {
|
||
purple->RemovePurple();
|
||
}
|
||
}
|
||
return !NeedsScriptTraverse(aNode);
|
||
}
|
||
|
||
AutoTArray<nsINode*, 1020>* gPurpleRoots = nullptr;
|
||
AutoTArray<nsIContent*, 1020>* gNodesToUnbind = nullptr;
|
||
|
||
void ClearCycleCollectorCleanupData()
|
||
{
|
||
if (gPurpleRoots) {
|
||
uint32_t len = gPurpleRoots->Length();
|
||
for (uint32_t i = 0; i < len; ++i) {
|
||
nsINode* n = gPurpleRoots->ElementAt(i);
|
||
n->SetIsPurpleRoot(false);
|
||
}
|
||
delete gPurpleRoots;
|
||
gPurpleRoots = nullptr;
|
||
}
|
||
if (gNodesToUnbind) {
|
||
uint32_t len = gNodesToUnbind->Length();
|
||
for (uint32_t i = 0; i < len; ++i) {
|
||
nsIContent* c = gNodesToUnbind->ElementAt(i);
|
||
c->SetIsPurpleRoot(false);
|
||
ContentUnbinder::Append(c);
|
||
}
|
||
delete gNodesToUnbind;
|
||
gNodesToUnbind = nullptr;
|
||
}
|
||
}
|
||
|
||
static bool
|
||
ShouldClearPurple(nsIContent* aContent)
|
||
{
|
||
MOZ_ASSERT(aContent);
|
||
if (aContent->IsPurple()) {
|
||
return true;
|
||
}
|
||
|
||
JSObject* o = GetJSObjectChild(aContent);
|
||
if (o && JS::ObjectIsMarkedGray(o)) {
|
||
return true;
|
||
}
|
||
|
||
if (aContent->HasListenerManager()) {
|
||
return true;
|
||
}
|
||
|
||
return aContent->HasProperties();
|
||
}
|
||
|
||
// If aNode is not optimizable, but is an element
|
||
// with a frame in a document which has currently active presshell,
|
||
// we can act as if it was optimizable. When the primary frame dies, aNode
|
||
// will end up to the purple buffer because of the refcount change.
|
||
bool
|
||
NodeHasActiveFrame(nsIDocument* aCurrentDoc, nsINode* aNode)
|
||
{
|
||
return aCurrentDoc->GetShell() && aNode->IsElement() &&
|
||
aNode->AsElement()->GetPrimaryFrame();
|
||
}
|
||
|
||
bool
|
||
OwnedByBindingManager(nsIDocument* aCurrentDoc, nsINode* aNode)
|
||
{
|
||
return aNode->IsElement() && aNode->AsElement()->GetXBLBinding();
|
||
}
|
||
|
||
// CanSkip checks if aNode is known-live, and if it is, returns true. If aNode
|
||
// is in a known-live DOM tree, CanSkip may also remove other objects from
|
||
// purple buffer and unmark event listeners and user data. If the root of the
|
||
// DOM tree is a document, less optimizations are done since checking the
|
||
// liveness of the current document is usually fast and we don't want slow down
|
||
// such common cases.
|
||
bool
|
||
FragmentOrElement::CanSkip(nsINode* aNode, bool aRemovingAllowed)
|
||
{
|
||
// Don't try to optimize anything during shutdown.
|
||
if (nsCCUncollectableMarker::sGeneration == 0) {
|
||
return false;
|
||
}
|
||
|
||
bool unoptimizable = aNode->UnoptimizableCCNode();
|
||
nsIDocument* currentDoc = aNode->GetUncomposedDoc();
|
||
if (currentDoc && IsCertainlyAliveNode(aNode, currentDoc) &&
|
||
(!unoptimizable || NodeHasActiveFrame(currentDoc, aNode) ||
|
||
OwnedByBindingManager(currentDoc, aNode))) {
|
||
MarkNodeChildren(aNode);
|
||
return true;
|
||
}
|
||
|
||
if (unoptimizable) {
|
||
return false;
|
||
}
|
||
|
||
nsINode* root = currentDoc ? static_cast<nsINode*>(currentDoc) :
|
||
FindOptimizableSubtreeRoot(aNode);
|
||
if (!root) {
|
||
return false;
|
||
}
|
||
|
||
// Subtree has been traversed already, and aNode has
|
||
// been handled in a way that doesn't require revisiting it.
|
||
if (root->IsPurpleRoot()) {
|
||
return false;
|
||
}
|
||
|
||
// nodesToClear contains nodes which are either purple or
|
||
// gray.
|
||
AutoTArray<nsIContent*, 1020> nodesToClear;
|
||
|
||
bool foundLiveWrapper = root->HasKnownLiveWrapper();
|
||
bool domOnlyCycle = false;
|
||
if (root != currentDoc) {
|
||
currentDoc = nullptr;
|
||
if (!foundLiveWrapper) {
|
||
domOnlyCycle = static_cast<nsIContent*>(root)->OwnedOnlyByTheDOMTree();
|
||
}
|
||
if (ShouldClearPurple(static_cast<nsIContent*>(root))) {
|
||
nodesToClear.AppendElement(static_cast<nsIContent*>(root));
|
||
}
|
||
}
|
||
|
||
// Traverse the subtree and check if we could know without CC
|
||
// that it is known-live.
|
||
// Note, this traverse is non-virtual and inline, so it should be a lot faster
|
||
// than CC's generic traverse.
|
||
for (nsIContent* node = root->GetFirstChild(); node;
|
||
node = node->GetNextNode(root)) {
|
||
foundLiveWrapper = foundLiveWrapper || node->HasKnownLiveWrapper();
|
||
if (foundLiveWrapper) {
|
||
domOnlyCycle = false;
|
||
if (currentDoc) {
|
||
// If we can mark the whole document live, no need to optimize
|
||
// so much, since when the next purple node in the document will be
|
||
// handled, it is fast to check that the currentDoc is in CCGeneration.
|
||
break;
|
||
}
|
||
// No need to put stuff to the nodesToClear array, if we can clear it
|
||
// already here.
|
||
if (node->IsPurple() && (node != aNode || aRemovingAllowed)) {
|
||
node->RemovePurple();
|
||
}
|
||
MarkNodeChildren(node);
|
||
} else {
|
||
domOnlyCycle = domOnlyCycle && node->OwnedOnlyByTheDOMTree();
|
||
if (ShouldClearPurple(node)) {
|
||
// Collect interesting nodes which we can clear if we find that
|
||
// they are kept alive in a known-live tree or are in a DOM-only cycle.
|
||
nodesToClear.AppendElement(node);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!currentDoc || !foundLiveWrapper) {
|
||
root->SetIsPurpleRoot(true);
|
||
if (domOnlyCycle) {
|
||
if (!gNodesToUnbind) {
|
||
gNodesToUnbind = new AutoTArray<nsIContent*, 1020>();
|
||
}
|
||
gNodesToUnbind->AppendElement(static_cast<nsIContent*>(root));
|
||
for (uint32_t i = 0; i < nodesToClear.Length(); ++i) {
|
||
nsIContent* n = nodesToClear[i];
|
||
if ((n != aNode || aRemovingAllowed) && n->IsPurple()) {
|
||
n->RemovePurple();
|
||
}
|
||
}
|
||
return true;
|
||
} else {
|
||
if (!gPurpleRoots) {
|
||
gPurpleRoots = new AutoTArray<nsINode*, 1020>();
|
||
}
|
||
gPurpleRoots->AppendElement(root);
|
||
}
|
||
}
|
||
|
||
if (!foundLiveWrapper) {
|
||
return false;
|
||
}
|
||
|
||
if (currentDoc) {
|
||
// Special case documents. If we know the document is known-live,
|
||
// we can mark the document to be in CCGeneration.
|
||
currentDoc->
|
||
MarkUncollectableForCCGeneration(nsCCUncollectableMarker::sGeneration);
|
||
MarkNodeChildren(currentDoc);
|
||
}
|
||
|
||
// Subtree is known-live, so we can remove purple nodes from
|
||
// purple buffer and mark stuff that to be certainly alive.
|
||
for (uint32_t i = 0; i < nodesToClear.Length(); ++i) {
|
||
nsIContent* n = nodesToClear[i];
|
||
MarkNodeChildren(n);
|
||
// Can't remove currently handled purple node,
|
||
// unless aRemovingAllowed is true.
|
||
if ((n != aNode || aRemovingAllowed) && n->IsPurple()) {
|
||
n->RemovePurple();
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool
|
||
FragmentOrElement::CanSkipThis(nsINode* aNode)
|
||
{
|
||
if (nsCCUncollectableMarker::sGeneration == 0) {
|
||
return false;
|
||
}
|
||
if (aNode->HasKnownLiveWrapper()) {
|
||
return true;
|
||
}
|
||
nsIDocument* c = aNode->GetUncomposedDoc();
|
||
return
|
||
((c && IsCertainlyAliveNode(aNode, c)) || aNode->InCCBlackTree()) &&
|
||
!NeedsScriptTraverse(aNode);
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::InitCCCallbacks()
|
||
{
|
||
nsCycleCollector_setForgetSkippableCallback(ClearCycleCollectorCleanupData);
|
||
nsCycleCollector_setBeforeUnlinkCallback(ClearBlackMarkedNodes);
|
||
}
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(FragmentOrElement)
|
||
return FragmentOrElement::CanSkip(tmp, aRemovingAllowed);
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(FragmentOrElement)
|
||
return FragmentOrElement::CanSkipInCC(tmp);
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
|
||
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(FragmentOrElement)
|
||
return FragmentOrElement::CanSkipThis(tmp);
|
||
NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
|
||
|
||
static const char* kNSURIs[] = {
|
||
" ([none])",
|
||
" (xmlns)",
|
||
" (xml)",
|
||
" (xhtml)",
|
||
" (XLink)",
|
||
" (XSLT)",
|
||
" (XBL)",
|
||
" (MathML)",
|
||
" (RDF)",
|
||
" (XUL)",
|
||
" (SVG)",
|
||
" (XML Events)"
|
||
};
|
||
|
||
// We purposefully don't TRAVERSE_BEGIN_INHERITED here. All the bits
|
||
// we should traverse should be added here or in nsINode::Traverse.
|
||
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(FragmentOrElement)
|
||
if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
|
||
char name[512];
|
||
uint32_t nsid = tmp->GetNameSpaceID();
|
||
nsAtomCString localName(tmp->NodeInfo()->NameAtom());
|
||
nsAutoCString uri;
|
||
if (tmp->OwnerDoc()->GetDocumentURI()) {
|
||
uri = tmp->OwnerDoc()->GetDocumentURI()->GetSpecOrDefault();
|
||
}
|
||
|
||
nsAutoString id;
|
||
nsAtom* idAtom = tmp->GetID();
|
||
if (idAtom) {
|
||
id.AppendLiteral(" id='");
|
||
id.Append(nsDependentAtomString(idAtom));
|
||
id.Append('\'');
|
||
}
|
||
|
||
nsAutoString classes;
|
||
const nsAttrValue* classAttrValue = tmp->IsElement() ?
|
||
tmp->AsElement()->GetClasses() : nullptr;
|
||
if (classAttrValue) {
|
||
classes.AppendLiteral(" class='");
|
||
nsAutoString classString;
|
||
classAttrValue->ToString(classString);
|
||
classString.ReplaceChar(char16_t('\n'), char16_t(' '));
|
||
classes.Append(classString);
|
||
classes.Append('\'');
|
||
}
|
||
|
||
nsAutoCString orphan;
|
||
if (!tmp->IsInComposedDoc() &&
|
||
// Ignore xbl:content, which is never in the document and hence always
|
||
// appears to be orphaned.
|
||
!tmp->NodeInfo()->Equals(nsGkAtoms::content, kNameSpaceID_XBL)) {
|
||
orphan.AppendLiteral(" (orphan)");
|
||
}
|
||
|
||
const char* nsuri = nsid < ArrayLength(kNSURIs) ? kNSURIs[nsid] : "";
|
||
SprintfLiteral(name, "FragmentOrElement%s %s%s%s%s %s",
|
||
nsuri,
|
||
localName.get(),
|
||
NS_ConvertUTF16toUTF8(id).get(),
|
||
NS_ConvertUTF16toUTF8(classes).get(),
|
||
orphan.get(),
|
||
uri.get());
|
||
cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
|
||
}
|
||
else {
|
||
NS_IMPL_CYCLE_COLLECTION_DESCRIBE(FragmentOrElement, tmp->mRefCnt.get())
|
||
}
|
||
|
||
if (!nsIContent::Traverse(tmp, cb)) {
|
||
return NS_SUCCESS_INTERRUPTED_TRAVERSE;
|
||
}
|
||
|
||
tmp->OwnerDoc()->BindingManager()->Traverse(tmp, cb);
|
||
|
||
// Check that whenever we have effect properties, MayHaveAnimations is set.
|
||
#ifdef DEBUG
|
||
nsAtom** effectProps = EffectSet::GetEffectSetPropertyAtoms();
|
||
for (uint32_t i = 0; effectProps[i]; ++i) {
|
||
MOZ_ASSERT_IF(tmp->GetProperty(effectProps[i]), tmp->MayHaveAnimations());
|
||
}
|
||
#endif
|
||
|
||
if (tmp->HasProperties()) {
|
||
if (tmp->IsElement()) {
|
||
Element* elem = tmp->AsElement();
|
||
IntersectionObserverList* observers =
|
||
static_cast<IntersectionObserverList*>(
|
||
elem->GetProperty(nsGkAtoms::intersectionobserverlist)
|
||
);
|
||
if (observers) {
|
||
for (auto iter = observers->Iter(); !iter.Done(); iter.Next()) {
|
||
DOMIntersectionObserver* observer = iter.Key();
|
||
cb.NoteXPCOMChild(observer);
|
||
}
|
||
}
|
||
}
|
||
if (tmp->IsHTMLElement() || tmp->IsSVGElement()) {
|
||
nsStaticAtom*** props = Element::HTMLSVGPropertiesToTraverseAndUnlink();
|
||
for (uint32_t i = 0; props[i]; ++i) {
|
||
nsISupports* property =
|
||
static_cast<nsISupports*>(tmp->GetProperty(*props[i]));
|
||
cb.NoteXPCOMChild(property);
|
||
}
|
||
if (tmp->MayHaveAnimations()) {
|
||
nsAtom** effectProps = EffectSet::GetEffectSetPropertyAtoms();
|
||
for (uint32_t i = 0; effectProps[i]; ++i) {
|
||
EffectSet* effectSet =
|
||
static_cast<EffectSet*>(tmp->GetProperty(effectProps[i]));
|
||
if (effectSet) {
|
||
effectSet->Traverse(cb);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Traverse attribute names and child content.
|
||
{
|
||
uint32_t i;
|
||
uint32_t attrs = tmp->mAttrsAndChildren.AttrCount();
|
||
for (i = 0; i < attrs; i++) {
|
||
const nsAttrName* name = tmp->mAttrsAndChildren.AttrNameAt(i);
|
||
if (!name->IsAtom()) {
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb,
|
||
"mAttrsAndChildren[i]->NodeInfo()");
|
||
cb.NoteNativeChild(name->NodeInfo(),
|
||
NS_CYCLE_COLLECTION_PARTICIPANT(NodeInfo));
|
||
}
|
||
}
|
||
|
||
uint32_t kids = tmp->mAttrsAndChildren.ChildCount();
|
||
for (i = 0; i < kids; i++) {
|
||
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mAttrsAndChildren[i]");
|
||
cb.NoteXPCOMChild(tmp->mAttrsAndChildren.GetSafeChildAt(i));
|
||
}
|
||
}
|
||
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
||
|
||
|
||
NS_INTERFACE_MAP_BEGIN(FragmentOrElement)
|
||
NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(FragmentOrElement)
|
||
NS_INTERFACE_MAP_END_INHERITING(nsIContent)
|
||
|
||
//----------------------------------------------------------------------
|
||
|
||
nsresult
|
||
FragmentOrElement::CopyInnerTo(FragmentOrElement* aDst,
|
||
bool aPreallocateChildren)
|
||
{
|
||
nsresult rv = aDst->mAttrsAndChildren.EnsureCapacityToClone(mAttrsAndChildren,
|
||
aPreallocateChildren);
|
||
NS_ENSURE_SUCCESS(rv, rv);
|
||
|
||
uint32_t i, count = mAttrsAndChildren.AttrCount();
|
||
for (i = 0; i < count; ++i) {
|
||
const nsAttrName* name = mAttrsAndChildren.AttrNameAt(i);
|
||
const nsAttrValue* value = mAttrsAndChildren.AttrAt(i);
|
||
nsAutoString valStr;
|
||
value->ToString(valStr);
|
||
rv = aDst->AsElement()->SetAttr(name->NamespaceID(), name->LocalName(),
|
||
name->GetPrefix(), valStr, false);
|
||
NS_ENSURE_SUCCESS(rv, rv);
|
||
}
|
||
|
||
return NS_OK;
|
||
}
|
||
|
||
const nsTextFragment*
|
||
FragmentOrElement::GetText()
|
||
{
|
||
return nullptr;
|
||
}
|
||
|
||
uint32_t
|
||
FragmentOrElement::TextLength() const
|
||
{
|
||
// We can remove this assertion if it turns out to be useful to be able
|
||
// to depend on this returning 0
|
||
NS_NOTREACHED("called FragmentOrElement::TextLength");
|
||
|
||
return 0;
|
||
}
|
||
|
||
bool
|
||
FragmentOrElement::TextIsOnlyWhitespace()
|
||
{
|
||
return false;
|
||
}
|
||
|
||
bool
|
||
FragmentOrElement::ThreadSafeTextIsOnlyWhitespace() const
|
||
{
|
||
return false;
|
||
}
|
||
|
||
uint32_t
|
||
FragmentOrElement::GetChildCount() const
|
||
{
|
||
return mAttrsAndChildren.ChildCount();
|
||
}
|
||
|
||
nsIContent *
|
||
FragmentOrElement::GetChildAt_Deprecated(uint32_t aIndex) const
|
||
{
|
||
return mAttrsAndChildren.GetSafeChildAt(aIndex);
|
||
}
|
||
|
||
int32_t
|
||
FragmentOrElement::ComputeIndexOf(const nsINode* aPossibleChild) const
|
||
{
|
||
return mAttrsAndChildren.IndexOfChild(aPossibleChild);
|
||
}
|
||
|
||
static inline bool
|
||
IsVoidTag(nsAtom* aTag)
|
||
{
|
||
static const nsAtom* voidElements[] = {
|
||
nsGkAtoms::area, nsGkAtoms::base, nsGkAtoms::basefont,
|
||
nsGkAtoms::bgsound, nsGkAtoms::br, nsGkAtoms::col,
|
||
nsGkAtoms::embed, nsGkAtoms::frame,
|
||
nsGkAtoms::hr, nsGkAtoms::img, nsGkAtoms::input,
|
||
nsGkAtoms::keygen, nsGkAtoms::link, nsGkAtoms::meta,
|
||
nsGkAtoms::param, nsGkAtoms::source, nsGkAtoms::track,
|
||
nsGkAtoms::wbr
|
||
};
|
||
|
||
static mozilla::BloomFilter<12, nsAtom> sFilter;
|
||
static bool sInitialized = false;
|
||
if (!sInitialized) {
|
||
sInitialized = true;
|
||
for (uint32_t i = 0; i < ArrayLength(voidElements); ++i) {
|
||
sFilter.add(voidElements[i]);
|
||
}
|
||
}
|
||
|
||
if (sFilter.mightContain(aTag)) {
|
||
for (uint32_t i = 0; i < ArrayLength(voidElements); ++i) {
|
||
if (aTag == voidElements[i]) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/* static */
|
||
bool
|
||
FragmentOrElement::IsHTMLVoid(nsAtom* aLocalName)
|
||
{
|
||
return aLocalName && IsVoidTag(aLocalName);
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::GetMarkup(bool aIncludeSelf, nsAString& aMarkup)
|
||
{
|
||
aMarkup.Truncate();
|
||
|
||
nsIDocument* doc = OwnerDoc();
|
||
if (IsInHTMLDocument()) {
|
||
nsContentUtils::SerializeNodeToMarkup(this, !aIncludeSelf, aMarkup);
|
||
return;
|
||
}
|
||
|
||
nsAutoString contentType;
|
||
doc->GetContentType(contentType);
|
||
bool tryToCacheEncoder = !aIncludeSelf;
|
||
|
||
nsCOMPtr<nsIDocumentEncoder> docEncoder = doc->GetCachedEncoder();
|
||
if (!docEncoder) {
|
||
docEncoder =
|
||
do_CreateInstance(PromiseFlatCString(
|
||
nsDependentCString(NS_DOC_ENCODER_CONTRACTID_BASE) +
|
||
NS_ConvertUTF16toUTF8(contentType)
|
||
).get());
|
||
}
|
||
if (!docEncoder) {
|
||
// This could be some type for which we create a synthetic document. Try
|
||
// again as XML
|
||
contentType.AssignLiteral("application/xml");
|
||
docEncoder = do_CreateInstance(NS_DOC_ENCODER_CONTRACTID_BASE "application/xml");
|
||
// Don't try to cache the encoder since it would point to a different
|
||
// contentType once it has been reinitialized.
|
||
tryToCacheEncoder = false;
|
||
}
|
||
|
||
NS_ENSURE_TRUE_VOID(docEncoder);
|
||
|
||
uint32_t flags = nsIDocumentEncoder::OutputEncodeBasicEntities |
|
||
// Output DOM-standard newlines
|
||
nsIDocumentEncoder::OutputLFLineBreak |
|
||
// Don't do linebreaking that's not present in
|
||
// the source
|
||
nsIDocumentEncoder::OutputRaw |
|
||
// Only check for mozdirty when necessary (bug 599983)
|
||
nsIDocumentEncoder::OutputIgnoreMozDirty;
|
||
|
||
if (IsEditable()) {
|
||
nsCOMPtr<Element> elem = do_QueryInterface(this);
|
||
TextEditor* textEditor = elem ? elem->GetTextEditorInternal() : nullptr;
|
||
if (textEditor && textEditor->OutputsMozDirty()) {
|
||
flags &= ~nsIDocumentEncoder::OutputIgnoreMozDirty;
|
||
}
|
||
}
|
||
|
||
DebugOnly<nsresult> rv = docEncoder->NativeInit(doc, contentType, flags);
|
||
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
||
|
||
if (aIncludeSelf) {
|
||
docEncoder->SetNativeNode(this);
|
||
} else {
|
||
docEncoder->SetNativeContainerNode(this);
|
||
}
|
||
rv = docEncoder->EncodeToString(aMarkup);
|
||
MOZ_ASSERT(NS_SUCCEEDED(rv));
|
||
if (tryToCacheEncoder) {
|
||
doc->SetCachedEncoder(docEncoder.forget());
|
||
}
|
||
}
|
||
|
||
static bool
|
||
ContainsMarkup(const nsAString& aStr)
|
||
{
|
||
// Note: we can't use FindCharInSet because null is one of the characters we
|
||
// want to search for.
|
||
const char16_t* start = aStr.BeginReading();
|
||
const char16_t* end = aStr.EndReading();
|
||
|
||
while (start != end) {
|
||
char16_t c = *start;
|
||
if (c == char16_t('<') ||
|
||
c == char16_t('&') ||
|
||
c == char16_t('\r') ||
|
||
c == char16_t('\0')) {
|
||
return true;
|
||
}
|
||
++start;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::SetInnerHTMLInternal(const nsAString& aInnerHTML, ErrorResult& aError,
|
||
bool aNeverSanitize)
|
||
{
|
||
FragmentOrElement* target = this;
|
||
// Handle template case.
|
||
if (nsNodeUtils::IsTemplateElement(target)) {
|
||
DocumentFragment* frag =
|
||
static_cast<HTMLTemplateElement*>(target)->Content();
|
||
MOZ_ASSERT(frag);
|
||
target = frag;
|
||
}
|
||
|
||
// Fast-path for strings with no markup. Limit this to short strings, to
|
||
// avoid ContainsMarkup taking too long. The choice for 100 is based on
|
||
// gut feeling.
|
||
//
|
||
// Don't do this for elements with a weird parser insertion mode, for
|
||
// instance setting innerHTML = "" on a <html> element should add the
|
||
// optional <head> and <body> elements.
|
||
if (!target->HasWeirdParserInsertionMode() &&
|
||
aInnerHTML.Length() < 100 && !ContainsMarkup(aInnerHTML)) {
|
||
aError = nsContentUtils::SetNodeTextContent(target, aInnerHTML, false);
|
||
return;
|
||
}
|
||
|
||
nsIDocument* doc = target->OwnerDoc();
|
||
|
||
// Batch possible DOMSubtreeModified events.
|
||
mozAutoSubtreeModified subtree(doc, nullptr);
|
||
|
||
target->FireNodeRemovedForChildren();
|
||
|
||
// Needed when innerHTML is used in combination with contenteditable
|
||
mozAutoDocUpdate updateBatch(doc, UPDATE_CONTENT_MODEL, true);
|
||
|
||
// Remove childnodes.
|
||
nsAutoMutationBatch mb(target, true, false);
|
||
while (target->HasChildren()) {
|
||
target->RemoveChildNode(target->GetFirstChild(), true);
|
||
}
|
||
mb.RemovalDone();
|
||
|
||
nsAutoScriptLoaderDisabler sld(doc);
|
||
|
||
nsAtom* contextLocalName = NodeInfo()->NameAtom();
|
||
int32_t contextNameSpaceID = GetNameSpaceID();
|
||
|
||
if (ShadowRoot* shadowRoot = ShadowRoot::FromNode(this)) {
|
||
// Fix up the context to be the host of the ShadowRoot.
|
||
contextLocalName = shadowRoot->GetHost()->NodeInfo()->NameAtom();
|
||
contextNameSpaceID = shadowRoot->GetHost()->GetNameSpaceID();
|
||
}
|
||
|
||
auto sanitize = (aNeverSanitize ? nsContentUtils::NeverSanitize
|
||
: nsContentUtils::SanitizeSystemPrivileged);
|
||
|
||
if (doc->IsHTMLDocument()) {
|
||
int32_t oldChildCount = target->GetChildCount();
|
||
aError = nsContentUtils::ParseFragmentHTML(aInnerHTML,
|
||
target,
|
||
contextLocalName,
|
||
contextNameSpaceID,
|
||
doc->GetCompatibilityMode() ==
|
||
eCompatibility_NavQuirks,
|
||
true,
|
||
sanitize);
|
||
mb.NodesAdded();
|
||
// HTML5 parser has notified, but not fired mutation events.
|
||
nsContentUtils::FireMutationEventsForDirectParsing(doc, target,
|
||
oldChildCount);
|
||
} else {
|
||
RefPtr<DocumentFragment> df =
|
||
nsContentUtils::CreateContextualFragment(target, aInnerHTML, true,
|
||
sanitize, aError);
|
||
if (!aError.Failed()) {
|
||
// Suppress assertion about node removal mutation events that can't have
|
||
// listeners anyway, because no one has had the chance to register mutation
|
||
// listeners on the fragment that comes from the parser.
|
||
nsAutoScriptBlockerSuppressNodeRemoved scriptBlocker;
|
||
|
||
static_cast<nsINode*>(target)->AppendChild(*df, aError);
|
||
mb.NodesAdded();
|
||
}
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::FireNodeRemovedForChildren()
|
||
{
|
||
nsIDocument* doc = OwnerDoc();
|
||
// Optimize the common case
|
||
if (!nsContentUtils::
|
||
HasMutationListeners(doc, NS_EVENT_BITS_MUTATION_NODEREMOVED)) {
|
||
return;
|
||
}
|
||
|
||
nsCOMPtr<nsIDocument> owningDoc = doc;
|
||
|
||
nsCOMPtr<nsINode> child;
|
||
for (child = GetFirstChild();
|
||
child && child->GetParentNode() == this;
|
||
child = child->GetNextSibling()) {
|
||
nsContentUtils::MaybeFireNodeRemoved(child, this, doc);
|
||
}
|
||
}
|
||
|
||
void
|
||
FragmentOrElement::AddSizeOfExcludingThis(nsWindowSizes& aSizes,
|
||
size_t* aNodeSize) const
|
||
{
|
||
nsIContent::AddSizeOfExcludingThis(aSizes, aNodeSize);
|
||
*aNodeSize +=
|
||
mAttrsAndChildren.SizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
|
||
|
||
nsDOMSlots* slots = GetExistingDOMSlots();
|
||
if (slots) {
|
||
*aNodeSize += slots->SizeOfIncludingThis(aSizes.mState.mMallocSizeOf);
|
||
}
|
||
}
|