From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/base/nsMappedAttributes.cpp | 283 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 283 insertions(+) create mode 100644 dom/base/nsMappedAttributes.cpp (limited to 'dom/base/nsMappedAttributes.cpp') diff --git a/dom/base/nsMappedAttributes.cpp b/dom/base/nsMappedAttributes.cpp new file mode 100644 index 000000000..a3accd2a7 --- /dev/null +++ b/dom/base/nsMappedAttributes.cpp @@ -0,0 +1,283 @@ +/* -*- 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/. */ + +/* + * A unique per-element set of attributes that is used as an + * nsIStyleRule; used to implement presentational attributes. + */ + +#include "nsMappedAttributes.h" +#include "nsHTMLStyleSheet.h" +#include "nsRuleWalker.h" +#include "mozilla/HashFunctions.h" +#include "mozilla/MemoryReporting.h" + +using namespace mozilla; + +nsMappedAttributes::nsMappedAttributes(nsHTMLStyleSheet* aSheet, + nsMapRuleToAttributesFunc aMapRuleFunc) + : mAttrCount(0), + mSheet(aSheet), + mRuleMapper(aMapRuleFunc) +{ +} + +nsMappedAttributes::nsMappedAttributes(const nsMappedAttributes& aCopy) + : mAttrCount(aCopy.mAttrCount), + mSheet(aCopy.mSheet), + mRuleMapper(aCopy.mRuleMapper) +{ + NS_ASSERTION(mBufferSize >= aCopy.mAttrCount, "can't fit attributes"); + + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + new (&Attrs()[i]) InternalAttr(aCopy.Attrs()[i]); + } +} + +nsMappedAttributes::~nsMappedAttributes() +{ + if (mSheet) { + mSheet->DropMappedAttributes(this); + } + + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + Attrs()[i].~InternalAttr(); + } +} + + +nsMappedAttributes* +nsMappedAttributes::Clone(bool aWillAddAttr) +{ + uint32_t extra = aWillAddAttr ? 1 : 0; + + // This will call the overridden operator new + return new (mAttrCount + extra) nsMappedAttributes(*this); +} + +void* nsMappedAttributes::operator new(size_t aSize, uint32_t aAttrCount) CPP_THROW_NEW +{ + NS_ASSERTION(aAttrCount > 0, "zero-attribute nsMappedAttributes requested"); + + // aSize will include the mAttrs buffer so subtract that. + void* newAttrs = ::operator new(aSize - sizeof(void*[1]) + + aAttrCount * sizeof(InternalAttr)); + +#ifdef DEBUG + static_cast(newAttrs)->mBufferSize = aAttrCount; +#endif + + return newAttrs; +} + +NS_IMPL_ISUPPORTS(nsMappedAttributes, + nsIStyleRule) + +void +nsMappedAttributes::SetAndTakeAttr(nsIAtom* aAttrName, nsAttrValue& aValue) +{ + NS_PRECONDITION(aAttrName, "null name"); + + uint32_t i; + for (i = 0; i < mAttrCount && !Attrs()[i].mName.IsSmaller(aAttrName); ++i) { + if (Attrs()[i].mName.Equals(aAttrName)) { + Attrs()[i].mValue.Reset(); + Attrs()[i].mValue.SwapValueWith(aValue); + return; + } + } + + NS_ASSERTION(mBufferSize >= mAttrCount + 1, "can't fit attributes"); + + if (mAttrCount != i) { + memmove(&Attrs()[i + 1], &Attrs()[i], (mAttrCount - i) * sizeof(InternalAttr)); + } + + new (&Attrs()[i].mName) nsAttrName(aAttrName); + new (&Attrs()[i].mValue) nsAttrValue(); + Attrs()[i].mValue.SwapValueWith(aValue); + ++mAttrCount; +} + +const nsAttrValue* +nsMappedAttributes::GetAttr(nsIAtom* aAttrName) const +{ + NS_PRECONDITION(aAttrName, "null name"); + + for (uint32_t i = 0; i < mAttrCount; ++i) { + if (Attrs()[i].mName.Equals(aAttrName)) { + return &Attrs()[i].mValue; + } + } + + return nullptr; +} + +const nsAttrValue* +nsMappedAttributes::GetAttr(const nsAString& aAttrName) const +{ + for (uint32_t i = 0; i < mAttrCount; ++i) { + if (Attrs()[i].mName.Atom()->Equals(aAttrName)) { + return &Attrs()[i].mValue; + } + } + + return nullptr; +} + +bool +nsMappedAttributes::Equals(const nsMappedAttributes* aOther) const +{ + if (this == aOther) { + return true; + } + + if (mRuleMapper != aOther->mRuleMapper || mAttrCount != aOther->mAttrCount) { + return false; + } + + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + if (!Attrs()[i].mName.Equals(aOther->Attrs()[i].mName) || + !Attrs()[i].mValue.Equals(aOther->Attrs()[i].mValue)) { + return false; + } + } + + return true; +} + +uint32_t +nsMappedAttributes::HashValue() const +{ + uint32_t hash = HashGeneric(mRuleMapper); + + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + hash = AddToHash(hash, + Attrs()[i].mName.HashValue(), + Attrs()[i].mValue.HashValue()); + } + + return hash; +} + +void +nsMappedAttributes::SetStyleSheet(nsHTMLStyleSheet* aSheet) +{ + if (mSheet) { + mSheet->DropMappedAttributes(this); + } + mSheet = aSheet; // not ref counted +} + +/* virtual */ void +nsMappedAttributes::MapRuleInfoInto(nsRuleData* aRuleData) +{ + if (mRuleMapper) { + (*mRuleMapper)(this, aRuleData); + } +} + +/* virtual */ bool +nsMappedAttributes::MightMapInheritedStyleData() +{ + // Just assume that we do, rather than adding checks to all of the different + // kinds of attribute mapping functions we have. + return true; +} + +/* virtual */ bool +nsMappedAttributes::GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty, + nsCSSValue* aValue) +{ + MOZ_ASSERT(false, "GetDiscretelyAnimatedCSSValue is not implemented yet"); + return false; +} + +#ifdef DEBUG +/* virtual */ void +nsMappedAttributes::List(FILE* out, int32_t aIndent) const +{ + nsAutoCString str; + nsAutoString tmp; + uint32_t i; + + for (i = 0; i < mAttrCount; ++i) { + int32_t indent; + for (indent = aIndent; indent > 0; --indent) { + str.AppendLiteral(" "); + } + + Attrs()[i].mName.GetQualifiedName(tmp); + LossyAppendUTF16toASCII(tmp, str); + + Attrs()[i].mValue.ToString(tmp); + LossyAppendUTF16toASCII(tmp, str); + str.Append('\n'); + fprintf_stderr(out, "%s", str.get()); + } +} +#endif + +void +nsMappedAttributes::RemoveAttrAt(uint32_t aPos, nsAttrValue& aValue) +{ + Attrs()[aPos].mValue.SwapValueWith(aValue); + Attrs()[aPos].~InternalAttr(); + memmove(&Attrs()[aPos], &Attrs()[aPos + 1], + (mAttrCount - aPos - 1) * sizeof(InternalAttr)); + mAttrCount--; +} + +const nsAttrName* +nsMappedAttributes::GetExistingAttrNameFromQName(const nsAString& aName) const +{ + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + if (Attrs()[i].mName.IsAtom()) { + if (Attrs()[i].mName.Atom()->Equals(aName)) { + return &Attrs()[i].mName; + } + } + else { + if (Attrs()[i].mName.NodeInfo()->QualifiedNameEquals(aName)) { + return &Attrs()[i].mName; + } + } + } + + return nullptr; +} + +int32_t +nsMappedAttributes::IndexOfAttr(nsIAtom* aLocalName) const +{ + uint32_t i; + for (i = 0; i < mAttrCount; ++i) { + if (Attrs()[i].mName.Equals(aLocalName)) { + return i; + } + } + + return -1; +} + +size_t +nsMappedAttributes::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const +{ + NS_ASSERTION(mAttrCount == mBufferSize, + "mBufferSize and mAttrCount are expected to be the same."); + + size_t n = aMallocSizeOf(this); + for (uint16_t i = 0; i < mAttrCount; ++i) { + n += Attrs()[i].mValue.SizeOfExcludingThis(aMallocSizeOf); + } + return n; +} + -- cgit v1.2.3