mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-11 12:25:53 +00:00
e74f1cd513
In order to facilitate the movement of code with side-effects called by Element::SetAttr to Element::BeforeSetAttr and Element::AfterSetAttr, Element::AfterSetAttr should have access to the old value of the attribute. This includes information about whether there was previously a value set or not. Accomplishing this involved passing an additional argument through functions that find and change the old attribute value in order to ensure that we can differentiate between an empty old value and an absent old value (attribute was not set). Note that while I tried to ensure that accurate values (and their absence) are reported to Element::AfterSetAttr, I largely ignored SVG. While the old value reported for SVG values should be however accurate the value already being reported to SetAttrAndNotify was, SVG elements do not currently report unset values properly because they will never pass a null pointer to SetAttrAndNotify. MozReview-Commit-ID: K1mha8CNFZP --HG-- extra : rebase_source : 42776eb01451d371e4aebcc17fe3dd112c8d268b
374 lines
9.5 KiB
C++
374 lines
9.5 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/. */
|
|
|
|
/*
|
|
* 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 "nsRuleData.h"
|
|
#include "nsRuleWalker.h"
|
|
#include "mozilla/GenericSpecifiedValues.h"
|
|
#include "mozilla/HashFunctions.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/ServoDeclarationBlock.h"
|
|
#include "mozilla/ServoSpecifiedValues.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
bool
|
|
nsMappedAttributes::sShuttingDown = false;
|
|
nsTArray<void*>*
|
|
nsMappedAttributes::sCachedMappedAttributeAllocations = nullptr;
|
|
|
|
void
|
|
nsMappedAttributes::Shutdown()
|
|
{
|
|
sShuttingDown = true;
|
|
if (sCachedMappedAttributeAllocations) {
|
|
for (uint32_t i = 0; i < sCachedMappedAttributeAllocations->Length(); ++i) {
|
|
void* cachedValue = (*sCachedMappedAttributeAllocations)[i];
|
|
::operator delete(cachedValue);
|
|
}
|
|
}
|
|
|
|
delete sCachedMappedAttributeAllocations;
|
|
sCachedMappedAttributeAllocations = nullptr;
|
|
}
|
|
|
|
nsMappedAttributes::nsMappedAttributes(nsHTMLStyleSheet* aSheet,
|
|
nsMapRuleToAttributesFunc aMapRuleFunc)
|
|
: mAttrCount(0),
|
|
mSheet(aSheet),
|
|
mRuleMapper(aMapRuleFunc),
|
|
mServoStyle(nullptr)
|
|
{
|
|
MOZ_ASSERT(mRefCnt == 0); // Ensure caching works as expected.
|
|
}
|
|
|
|
nsMappedAttributes::nsMappedAttributes(const nsMappedAttributes& aCopy)
|
|
: mAttrCount(aCopy.mAttrCount),
|
|
mSheet(aCopy.mSheet),
|
|
mRuleMapper(aCopy.mRuleMapper),
|
|
// This is only called by ::Clone, which is used to create independent
|
|
// nsMappedAttributes objects which should not share a ServoDeclarationBlock
|
|
mServoStyle(nullptr)
|
|
{
|
|
NS_ASSERTION(mBufferSize >= aCopy.mAttrCount, "can't fit attributes");
|
|
MOZ_ASSERT(mRefCnt == 0); // Ensure caching works as expected.
|
|
|
|
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
|
|
{
|
|
|
|
size_t size = aSize + aAttrCount * sizeof(InternalAttr);
|
|
|
|
// aSize will include the mAttrs buffer so subtract that.
|
|
// We don't want to under-allocate, however, so do not subtract
|
|
// if we have zero attributes. The zero attribute case only happens
|
|
// for <body>'s mapped attributes
|
|
if (aAttrCount != 0) {
|
|
size -= sizeof(void*[1]);
|
|
}
|
|
|
|
if (sCachedMappedAttributeAllocations) {
|
|
void* cached =
|
|
sCachedMappedAttributeAllocations->SafeElementAt(aAttrCount);
|
|
if (cached) {
|
|
(*sCachedMappedAttributeAllocations)[aAttrCount] = nullptr;
|
|
return cached;
|
|
}
|
|
}
|
|
|
|
void* newAttrs = ::operator new(size);
|
|
|
|
#ifdef DEBUG
|
|
static_cast<nsMappedAttributes*>(newAttrs)->mBufferSize = aAttrCount;
|
|
#endif
|
|
return newAttrs;
|
|
}
|
|
|
|
void
|
|
nsMappedAttributes::LastRelease()
|
|
{
|
|
if (!sShuttingDown) {
|
|
if (!sCachedMappedAttributeAllocations) {
|
|
sCachedMappedAttributeAllocations = new nsTArray<void*>();
|
|
}
|
|
|
|
// Ensure the cache array is at least mAttrCount + 1 long and
|
|
// that each item is either null or pointing to a cached item.
|
|
// The size of the array is capped because mapped attributes are defined
|
|
// statically in element implementations.
|
|
sCachedMappedAttributeAllocations->SetCapacity(mAttrCount + 1);
|
|
for (uint32_t i = sCachedMappedAttributeAllocations->Length();
|
|
i < (uint32_t(mAttrCount) + 1); ++i) {
|
|
sCachedMappedAttributeAllocations->AppendElement(nullptr);
|
|
}
|
|
|
|
if (!(*sCachedMappedAttributeAllocations)[mAttrCount]) {
|
|
void* memoryToCache = this;
|
|
this->~nsMappedAttributes();
|
|
(*sCachedMappedAttributeAllocations)[mAttrCount] = memoryToCache;
|
|
return;
|
|
}
|
|
}
|
|
|
|
delete this;
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsMappedAttributes)
|
|
NS_IMPL_RELEASE_WITH_DESTROY(nsMappedAttributes, LastRelease())
|
|
|
|
NS_IMPL_QUERY_INTERFACE(nsMappedAttributes,
|
|
nsIStyleRule)
|
|
|
|
void
|
|
nsMappedAttributes::SetAndSwapAttr(nsIAtom* aAttrName, nsAttrValue& aValue,
|
|
bool* aValueWasSet)
|
|
{
|
|
NS_PRECONDITION(aAttrName, "null name");
|
|
*aValueWasSet = false;
|
|
uint32_t i;
|
|
for (i = 0; i < mAttrCount && !Attrs()[i].mName.IsSmaller(aAttrName); ++i) {
|
|
if (Attrs()[i].mName.Equals(aAttrName)) {
|
|
Attrs()[i].mValue.SwapValueWith(aValue);
|
|
*aValueWasSet = true;
|
|
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;
|
|
}
|
|
|
|
void
|
|
nsMappedAttributes::LazilyResolveServoDeclaration(nsPresContext* aContext)
|
|
{
|
|
|
|
MOZ_ASSERT(!mServoStyle,
|
|
"LazilyResolveServoDeclaration should not be called if mServoStyle is already set");
|
|
if (mRuleMapper) {
|
|
mServoStyle = Servo_DeclarationBlock_CreateEmpty().Consume();
|
|
ServoSpecifiedValues servo = ServoSpecifiedValues(aContext, mServoStyle.get());
|
|
(*mRuleMapper)(this, &servo);
|
|
}
|
|
}
|