d871b9515f
CLOSED TREE Backed out changeset d66c3f19a210 (bug 1235261) Backed out changeset 467d945426bb (bug 1235261) Backed out changeset 32b61df13142 (bug 1235261) Backed out changeset c50bb8ed4196 (bug 1235261) Backed out changeset 0ff0fa6fe81f (bug 1235261) Backed out changeset df70e89669da (bug 1235261) Backed out changeset 064969357fc9 (bug 1235261)
2320 lines
64 KiB
C++
2320 lines
64 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
// vim:cindent:tabstop=2:expandtab:shiftwidth=2:
|
|
/* 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/. */
|
|
|
|
/* representation of a CSS style sheet */
|
|
|
|
#include "mozilla/CSSStyleSheet.h"
|
|
|
|
#include "nsIAtom.h"
|
|
#include "nsCSSRuleProcessor.h"
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/ShadowRoot.h"
|
|
#include "mozilla/dom/MediaListBinding.h"
|
|
#include "mozilla/css/NameSpaceRule.h"
|
|
#include "mozilla/css/GroupRule.h"
|
|
#include "mozilla/css/ImportRule.h"
|
|
#include "nsCSSRules.h"
|
|
#include "nsIMediaList.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsQueryObject.h"
|
|
#include "nsString.h"
|
|
#include "nsTArray.h"
|
|
#include "nsIDOMCSSStyleSheet.h"
|
|
#include "mozilla/dom/CSSRuleList.h"
|
|
#include "nsIDOMMediaList.h"
|
|
#include "nsIDOMNode.h"
|
|
#include "nsError.h"
|
|
#include "nsCSSParser.h"
|
|
#include "mozilla/css/Loader.h"
|
|
#include "nsICSSLoaderObserver.h"
|
|
#include "nsNameSpaceManager.h"
|
|
#include "nsXMLNameSpaceMap.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIScriptSecurityManager.h"
|
|
#include "mozAutoDocUpdate.h"
|
|
#include "nsRuleNode.h"
|
|
#include "nsMediaFeatures.h"
|
|
#include "nsDOMClassInfoID.h"
|
|
#include "mozilla/Likely.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsNullPrincipal.h"
|
|
#include "mozilla/RuleProcessorCache.h"
|
|
#include "nsIStyleSheetLinkingElement.h"
|
|
#include "nsDOMWindowUtils.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
// -------------------------------
|
|
// Style Rule List for the DOM
|
|
//
|
|
class CSSRuleListImpl final : public CSSRuleList
|
|
{
|
|
public:
|
|
explicit CSSRuleListImpl(CSSStyleSheet *aStyleSheet);
|
|
|
|
virtual CSSStyleSheet* GetParentObject() override;
|
|
|
|
virtual nsIDOMCSSRule*
|
|
IndexedGetter(uint32_t aIndex, bool& aFound) override;
|
|
virtual uint32_t
|
|
Length() override;
|
|
|
|
void DropReference() { mStyleSheet = nullptr; }
|
|
|
|
protected:
|
|
virtual ~CSSRuleListImpl();
|
|
|
|
CSSStyleSheet* mStyleSheet;
|
|
};
|
|
|
|
CSSRuleListImpl::CSSRuleListImpl(CSSStyleSheet *aStyleSheet)
|
|
{
|
|
// Not reference counted to avoid circular references.
|
|
// The style sheet will tell us when its going away.
|
|
mStyleSheet = aStyleSheet;
|
|
}
|
|
|
|
CSSRuleListImpl::~CSSRuleListImpl()
|
|
{
|
|
}
|
|
|
|
CSSStyleSheet*
|
|
CSSRuleListImpl::GetParentObject()
|
|
{
|
|
return mStyleSheet;
|
|
}
|
|
|
|
uint32_t
|
|
CSSRuleListImpl::Length()
|
|
{
|
|
if (!mStyleSheet) {
|
|
return 0;
|
|
}
|
|
|
|
return AssertedCast<uint32_t>(mStyleSheet->StyleRuleCount());
|
|
}
|
|
|
|
nsIDOMCSSRule*
|
|
CSSRuleListImpl::IndexedGetter(uint32_t aIndex, bool& aFound)
|
|
{
|
|
aFound = false;
|
|
|
|
if (mStyleSheet) {
|
|
// ensure rules have correct parent
|
|
mStyleSheet->EnsureUniqueInner();
|
|
css::Rule* rule = mStyleSheet->GetStyleRuleAt(aIndex);
|
|
if (rule) {
|
|
aFound = true;
|
|
return rule->GetDOMRule();
|
|
}
|
|
}
|
|
|
|
// Per spec: "Return Value ... null if ... not a valid index."
|
|
return nullptr;
|
|
}
|
|
|
|
template <class Numeric>
|
|
int32_t DoCompare(Numeric a, Numeric b)
|
|
{
|
|
if (a == b)
|
|
return 0;
|
|
if (a < b)
|
|
return -1;
|
|
return 1;
|
|
}
|
|
|
|
bool
|
|
nsMediaExpression::Matches(nsPresContext *aPresContext,
|
|
const nsCSSValue& aActualValue) const
|
|
{
|
|
const nsCSSValue& actual = aActualValue;
|
|
const nsCSSValue& required = mValue;
|
|
|
|
// If we don't have the feature, the match fails.
|
|
if (actual.GetUnit() == eCSSUnit_Null) {
|
|
return false;
|
|
}
|
|
|
|
// If the expression had no value to match, the match succeeds,
|
|
// unless the value is an integer 0 or a zero length.
|
|
if (required.GetUnit() == eCSSUnit_Null) {
|
|
if (actual.GetUnit() == eCSSUnit_Integer)
|
|
return actual.GetIntValue() != 0;
|
|
if (actual.IsLengthUnit())
|
|
return actual.GetFloatValue() != 0;
|
|
return true;
|
|
}
|
|
|
|
NS_ASSERTION(mFeature->mRangeType == nsMediaFeature::eMinMaxAllowed ||
|
|
mRange == nsMediaExpression::eEqual, "yikes");
|
|
int32_t cmp; // -1 (actual < required)
|
|
// 0 (actual == required)
|
|
// 1 (actual > required)
|
|
switch (mFeature->mValueType) {
|
|
case nsMediaFeature::eLength:
|
|
{
|
|
NS_ASSERTION(actual.IsLengthUnit(), "bad actual value");
|
|
NS_ASSERTION(required.IsLengthUnit(), "bad required value");
|
|
nscoord actualCoord = nsRuleNode::CalcLengthWithInitialFont(
|
|
aPresContext, actual);
|
|
nscoord requiredCoord = nsRuleNode::CalcLengthWithInitialFont(
|
|
aPresContext, required);
|
|
cmp = DoCompare(actualCoord, requiredCoord);
|
|
}
|
|
break;
|
|
case nsMediaFeature::eInteger:
|
|
case nsMediaFeature::eBoolInteger:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Integer,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Integer,
|
|
"bad required value");
|
|
NS_ASSERTION(mFeature->mValueType != nsMediaFeature::eBoolInteger ||
|
|
actual.GetIntValue() == 0 || actual.GetIntValue() == 1,
|
|
"bad actual bool integer value");
|
|
NS_ASSERTION(mFeature->mValueType != nsMediaFeature::eBoolInteger ||
|
|
required.GetIntValue() == 0 || required.GetIntValue() == 1,
|
|
"bad required bool integer value");
|
|
cmp = DoCompare(actual.GetIntValue(), required.GetIntValue());
|
|
}
|
|
break;
|
|
case nsMediaFeature::eFloat:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Number,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Number,
|
|
"bad required value");
|
|
cmp = DoCompare(actual.GetFloatValue(), required.GetFloatValue());
|
|
}
|
|
break;
|
|
case nsMediaFeature::eIntRatio:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Array &&
|
|
actual.GetArrayValue()->Count() == 2 &&
|
|
actual.GetArrayValue()->Item(0).GetUnit() ==
|
|
eCSSUnit_Integer &&
|
|
actual.GetArrayValue()->Item(1).GetUnit() ==
|
|
eCSSUnit_Integer,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Array &&
|
|
required.GetArrayValue()->Count() == 2 &&
|
|
required.GetArrayValue()->Item(0).GetUnit() ==
|
|
eCSSUnit_Integer &&
|
|
required.GetArrayValue()->Item(1).GetUnit() ==
|
|
eCSSUnit_Integer,
|
|
"bad required value");
|
|
// Convert to int64_t so we can multiply without worry. Note
|
|
// that while the spec requires that both halves of |required|
|
|
// be positive, the numerator or denominator of |actual| might
|
|
// be zero (e.g., when testing 'aspect-ratio' on a 0-width or
|
|
// 0-height iframe).
|
|
int64_t actualNum = actual.GetArrayValue()->Item(0).GetIntValue(),
|
|
actualDen = actual.GetArrayValue()->Item(1).GetIntValue(),
|
|
requiredNum = required.GetArrayValue()->Item(0).GetIntValue(),
|
|
requiredDen = required.GetArrayValue()->Item(1).GetIntValue();
|
|
cmp = DoCompare(actualNum * requiredDen, requiredNum * actualDen);
|
|
}
|
|
break;
|
|
case nsMediaFeature::eResolution:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Inch ||
|
|
actual.GetUnit() == eCSSUnit_Pixel ||
|
|
actual.GetUnit() == eCSSUnit_Centimeter,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Inch ||
|
|
required.GetUnit() == eCSSUnit_Pixel ||
|
|
required.GetUnit() == eCSSUnit_Centimeter,
|
|
"bad required value");
|
|
float actualDPI = actual.GetFloatValue();
|
|
if (actual.GetUnit() == eCSSUnit_Centimeter) {
|
|
actualDPI = actualDPI * 2.54f;
|
|
} else if (actual.GetUnit() == eCSSUnit_Pixel) {
|
|
actualDPI = actualDPI * 96.0f;
|
|
}
|
|
float requiredDPI = required.GetFloatValue();
|
|
if (required.GetUnit() == eCSSUnit_Centimeter) {
|
|
requiredDPI = requiredDPI * 2.54f;
|
|
} else if (required.GetUnit() == eCSSUnit_Pixel) {
|
|
requiredDPI = requiredDPI * 96.0f;
|
|
}
|
|
cmp = DoCompare(actualDPI, requiredDPI);
|
|
}
|
|
break;
|
|
case nsMediaFeature::eEnumerated:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Enumerated,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Enumerated,
|
|
"bad required value");
|
|
NS_ASSERTION(mFeature->mRangeType == nsMediaFeature::eMinMaxNotAllowed,
|
|
"bad range"); // we asserted above about mRange
|
|
// We don't really need DoCompare, but it doesn't hurt (and
|
|
// maybe the compiler will condense this case with eInteger).
|
|
cmp = DoCompare(actual.GetIntValue(), required.GetIntValue());
|
|
}
|
|
break;
|
|
case nsMediaFeature::eIdent:
|
|
{
|
|
NS_ASSERTION(actual.GetUnit() == eCSSUnit_Ident,
|
|
"bad actual value");
|
|
NS_ASSERTION(required.GetUnit() == eCSSUnit_Ident,
|
|
"bad required value");
|
|
NS_ASSERTION(mFeature->mRangeType == nsMediaFeature::eMinMaxNotAllowed,
|
|
"bad range");
|
|
cmp = !(actual == required); // string comparison
|
|
}
|
|
break;
|
|
}
|
|
switch (mRange) {
|
|
case nsMediaExpression::eMin:
|
|
return cmp != -1;
|
|
case nsMediaExpression::eMax:
|
|
return cmp != 1;
|
|
case nsMediaExpression::eEqual:
|
|
return cmp == 0;
|
|
}
|
|
NS_NOTREACHED("unexpected mRange");
|
|
return false;
|
|
}
|
|
|
|
void
|
|
nsMediaQueryResultCacheKey::AddExpression(const nsMediaExpression* aExpression,
|
|
bool aExpressionMatches)
|
|
{
|
|
const nsMediaFeature *feature = aExpression->mFeature;
|
|
FeatureEntry *entry = nullptr;
|
|
for (uint32_t i = 0; i < mFeatureCache.Length(); ++i) {
|
|
if (mFeatureCache[i].mFeature == feature) {
|
|
entry = &mFeatureCache[i];
|
|
break;
|
|
}
|
|
}
|
|
if (!entry) {
|
|
entry = mFeatureCache.AppendElement();
|
|
if (!entry) {
|
|
return; /* out of memory */
|
|
}
|
|
entry->mFeature = feature;
|
|
}
|
|
|
|
ExpressionEntry eentry = { *aExpression, aExpressionMatches };
|
|
entry->mExpressions.AppendElement(eentry);
|
|
}
|
|
|
|
bool
|
|
nsMediaQueryResultCacheKey::Matches(nsPresContext* aPresContext) const
|
|
{
|
|
if (aPresContext->Medium() != mMedium) {
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < mFeatureCache.Length(); ++i) {
|
|
const FeatureEntry *entry = &mFeatureCache[i];
|
|
nsCSSValue actual;
|
|
nsresult rv =
|
|
(entry->mFeature->mGetter)(aPresContext, entry->mFeature, actual);
|
|
NS_ENSURE_SUCCESS(rv, false); // any better ideas?
|
|
|
|
for (uint32_t j = 0; j < entry->mExpressions.Length(); ++j) {
|
|
const ExpressionEntry &eentry = entry->mExpressions[j];
|
|
if (eentry.mExpression.Matches(aPresContext, actual) !=
|
|
eentry.mExpressionMatches) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
nsDocumentRuleResultCacheKey::AddMatchingRule(css::DocumentRule* aRule)
|
|
{
|
|
MOZ_ASSERT(!mFinalized);
|
|
return mMatchingRules.AppendElement(aRule);
|
|
}
|
|
|
|
void
|
|
nsDocumentRuleResultCacheKey::Finalize()
|
|
{
|
|
mMatchingRules.Sort();
|
|
#ifdef DEBUG
|
|
mFinalized = true;
|
|
#endif
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
static bool
|
|
ArrayIsSorted(const nsTArray<css::DocumentRule*>& aRules)
|
|
{
|
|
for (size_t i = 1; i < aRules.Length(); i++) {
|
|
if (aRules[i - 1] > aRules[i]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
nsDocumentRuleResultCacheKey::Matches(
|
|
nsPresContext* aPresContext,
|
|
const nsTArray<css::DocumentRule*>& aRules) const
|
|
{
|
|
MOZ_ASSERT(mFinalized);
|
|
MOZ_ASSERT(ArrayIsSorted(mMatchingRules));
|
|
MOZ_ASSERT(ArrayIsSorted(aRules));
|
|
|
|
#ifdef DEBUG
|
|
for (css::DocumentRule* rule : mMatchingRules) {
|
|
MOZ_ASSERT(aRules.BinaryIndexOf(rule) != aRules.NoIndex,
|
|
"aRules must contain all rules in mMatchingRules");
|
|
}
|
|
#endif
|
|
|
|
// First check that aPresContext matches all the rules listed in
|
|
// mMatchingRules.
|
|
for (css::DocumentRule* rule : mMatchingRules) {
|
|
if (!rule->UseForPresentation(aPresContext)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Then check that all the rules in aRules that aren't also in
|
|
// mMatchingRules do not match.
|
|
|
|
// pointer to matching rules
|
|
auto pm = mMatchingRules.begin();
|
|
auto pm_end = mMatchingRules.end();
|
|
|
|
// pointer to all rules
|
|
auto pr = aRules.begin();
|
|
auto pr_end = aRules.end();
|
|
|
|
// mMatchingRules and aRules are both sorted by their pointer values,
|
|
// so we can iterate over the two lists simultaneously.
|
|
while (pr < pr_end) {
|
|
while (pm < pm_end && *pm < *pr) {
|
|
++pm;
|
|
}
|
|
if (pm >= pm_end || *pm != *pr) {
|
|
if ((*pr)->UseForPresentation(aPresContext)) {
|
|
return false;
|
|
}
|
|
}
|
|
++pr;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsDocumentRuleResultCacheKey::List(FILE* aOut, int32_t aIndent) const
|
|
{
|
|
for (css::DocumentRule* rule : mMatchingRules) {
|
|
nsCString str;
|
|
|
|
for (int32_t i = 0; i < aIndent; i++) {
|
|
str.AppendLiteral(" ");
|
|
}
|
|
str.AppendLiteral("{ ");
|
|
|
|
nsString condition;
|
|
rule->GetConditionText(condition);
|
|
AppendUTF16toUTF8(condition, str);
|
|
|
|
str.AppendLiteral(" }\n");
|
|
fprintf_stderr(aOut, "%s", str.get());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
size_t
|
|
nsDocumentRuleResultCacheKey::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
size_t n = 0;
|
|
n += mMatchingRules.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
return n;
|
|
}
|
|
|
|
void
|
|
nsMediaQuery::AppendToString(nsAString& aString) const
|
|
{
|
|
if (mHadUnknownExpression) {
|
|
aString.AppendLiteral("not all");
|
|
return;
|
|
}
|
|
|
|
NS_ASSERTION(!mNegated || !mHasOnly, "can't have not and only");
|
|
NS_ASSERTION(!mTypeOmitted || (!mNegated && !mHasOnly),
|
|
"can't have not or only when type is omitted");
|
|
if (!mTypeOmitted) {
|
|
if (mNegated) {
|
|
aString.AppendLiteral("not ");
|
|
} else if (mHasOnly) {
|
|
aString.AppendLiteral("only ");
|
|
}
|
|
aString.Append(nsDependentAtomString(mMediaType));
|
|
}
|
|
|
|
for (uint32_t i = 0, i_end = mExpressions.Length(); i < i_end; ++i) {
|
|
if (i > 0 || !mTypeOmitted)
|
|
aString.AppendLiteral(" and ");
|
|
aString.Append('(');
|
|
|
|
const nsMediaExpression &expr = mExpressions[i];
|
|
const nsMediaFeature *feature = expr.mFeature;
|
|
if (feature->mReqFlags & nsMediaFeature::eHasWebkitPrefix) {
|
|
aString.AppendLiteral("-webkit-");
|
|
}
|
|
if (expr.mRange == nsMediaExpression::eMin) {
|
|
aString.AppendLiteral("min-");
|
|
} else if (expr.mRange == nsMediaExpression::eMax) {
|
|
aString.AppendLiteral("max-");
|
|
}
|
|
|
|
aString.Append(nsDependentAtomString(*feature->mName));
|
|
|
|
if (expr.mValue.GetUnit() != eCSSUnit_Null) {
|
|
aString.AppendLiteral(": ");
|
|
switch (feature->mValueType) {
|
|
case nsMediaFeature::eLength:
|
|
NS_ASSERTION(expr.mValue.IsLengthUnit(), "bad unit");
|
|
// Use 'width' as a property that takes length values
|
|
// written in the normal way.
|
|
expr.mValue.AppendToString(eCSSProperty_width, aString,
|
|
nsCSSValue::eNormalized);
|
|
break;
|
|
case nsMediaFeature::eInteger:
|
|
case nsMediaFeature::eBoolInteger:
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Integer,
|
|
"bad unit");
|
|
// Use 'z-index' as a property that takes integer values
|
|
// written without anything extra.
|
|
expr.mValue.AppendToString(eCSSProperty_z_index, aString,
|
|
nsCSSValue::eNormalized);
|
|
break;
|
|
case nsMediaFeature::eFloat:
|
|
{
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Number,
|
|
"bad unit");
|
|
// Use 'line-height' as a property that takes float values
|
|
// written in the normal way.
|
|
expr.mValue.AppendToString(eCSSProperty_line_height, aString,
|
|
nsCSSValue::eNormalized);
|
|
}
|
|
break;
|
|
case nsMediaFeature::eIntRatio:
|
|
{
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Array,
|
|
"bad unit");
|
|
nsCSSValue::Array *array = expr.mValue.GetArrayValue();
|
|
NS_ASSERTION(array->Count() == 2, "unexpected length");
|
|
NS_ASSERTION(array->Item(0).GetUnit() == eCSSUnit_Integer,
|
|
"bad unit");
|
|
NS_ASSERTION(array->Item(1).GetUnit() == eCSSUnit_Integer,
|
|
"bad unit");
|
|
array->Item(0).AppendToString(eCSSProperty_z_index, aString,
|
|
nsCSSValue::eNormalized);
|
|
aString.Append('/');
|
|
array->Item(1).AppendToString(eCSSProperty_z_index, aString,
|
|
nsCSSValue::eNormalized);
|
|
}
|
|
break;
|
|
case nsMediaFeature::eResolution:
|
|
{
|
|
aString.AppendFloat(expr.mValue.GetFloatValue());
|
|
if (expr.mValue.GetUnit() == eCSSUnit_Inch) {
|
|
aString.AppendLiteral("dpi");
|
|
} else if (expr.mValue.GetUnit() == eCSSUnit_Pixel) {
|
|
aString.AppendLiteral("dppx");
|
|
} else {
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Centimeter,
|
|
"bad unit");
|
|
aString.AppendLiteral("dpcm");
|
|
}
|
|
}
|
|
break;
|
|
case nsMediaFeature::eEnumerated:
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Enumerated,
|
|
"bad unit");
|
|
AppendASCIItoUTF16(
|
|
nsCSSProps::ValueToKeyword(expr.mValue.GetIntValue(),
|
|
feature->mData.mKeywordTable),
|
|
aString);
|
|
break;
|
|
case nsMediaFeature::eIdent:
|
|
NS_ASSERTION(expr.mValue.GetUnit() == eCSSUnit_Ident,
|
|
"bad unit");
|
|
aString.Append(expr.mValue.GetStringBufferValue());
|
|
break;
|
|
}
|
|
}
|
|
|
|
aString.Append(')');
|
|
}
|
|
}
|
|
|
|
nsMediaQuery*
|
|
nsMediaQuery::Clone() const
|
|
{
|
|
return new nsMediaQuery(*this);
|
|
}
|
|
|
|
bool
|
|
nsMediaQuery::Matches(nsPresContext* aPresContext,
|
|
nsMediaQueryResultCacheKey* aKey) const
|
|
{
|
|
if (mHadUnknownExpression)
|
|
return false;
|
|
|
|
bool match =
|
|
mMediaType == aPresContext->Medium() || mMediaType == nsGkAtoms::all;
|
|
for (uint32_t i = 0, i_end = mExpressions.Length(); match && i < i_end; ++i) {
|
|
const nsMediaExpression &expr = mExpressions[i];
|
|
nsCSSValue actual;
|
|
nsresult rv =
|
|
(expr.mFeature->mGetter)(aPresContext, expr.mFeature, actual);
|
|
NS_ENSURE_SUCCESS(rv, false); // any better ideas?
|
|
|
|
match = expr.Matches(aPresContext, actual);
|
|
if (aKey) {
|
|
aKey->AddExpression(&expr, match);
|
|
}
|
|
}
|
|
|
|
return match == !mNegated;
|
|
}
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsMediaList)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMMediaList)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsMediaList)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsMediaList)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(nsMediaList)
|
|
|
|
nsMediaList::nsMediaList()
|
|
: mStyleSheet(nullptr)
|
|
{
|
|
}
|
|
|
|
nsMediaList::~nsMediaList()
|
|
{
|
|
}
|
|
|
|
/* virtual */ JSObject*
|
|
nsMediaList::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return MediaListBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
void
|
|
nsMediaList::GetText(nsAString& aMediaText)
|
|
{
|
|
aMediaText.Truncate();
|
|
|
|
for (int32_t i = 0, i_end = mArray.Length(); i < i_end; ++i) {
|
|
nsMediaQuery* query = mArray[i];
|
|
|
|
query->AppendToString(aMediaText);
|
|
|
|
if (i + 1 < i_end) {
|
|
aMediaText.AppendLiteral(", ");
|
|
}
|
|
}
|
|
}
|
|
|
|
// XXXbz this is so ill-defined in the spec, it's not clear quite what
|
|
// it should be doing....
|
|
void
|
|
nsMediaList::SetText(const nsAString& aMediaText)
|
|
{
|
|
nsCSSParser parser;
|
|
|
|
bool htmlMode = mStyleSheet && mStyleSheet->GetOwnerNode();
|
|
|
|
parser.ParseMediaList(aMediaText, nullptr, 0, this, htmlMode);
|
|
}
|
|
|
|
bool
|
|
nsMediaList::Matches(nsPresContext* aPresContext,
|
|
nsMediaQueryResultCacheKey* aKey)
|
|
{
|
|
for (int32_t i = 0, i_end = mArray.Length(); i < i_end; ++i) {
|
|
if (mArray[i]->Matches(aPresContext, aKey)) {
|
|
return true;
|
|
}
|
|
}
|
|
return mArray.IsEmpty();
|
|
}
|
|
|
|
void
|
|
nsMediaList::SetStyleSheet(CSSStyleSheet* aSheet)
|
|
{
|
|
NS_ASSERTION(aSheet == mStyleSheet || !aSheet || !mStyleSheet,
|
|
"multiple style sheets competing for one media list");
|
|
mStyleSheet = aSheet;
|
|
}
|
|
|
|
already_AddRefed<nsMediaList>
|
|
nsMediaList::Clone()
|
|
{
|
|
RefPtr<nsMediaList> result = new nsMediaList();
|
|
result->mArray.AppendElements(mArray.Length());
|
|
for (uint32_t i = 0, i_end = mArray.Length(); i < i_end; ++i) {
|
|
result->mArray[i] = mArray[i]->Clone();
|
|
MOZ_ASSERT(result->mArray[i]);
|
|
}
|
|
return result.forget();
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::GetMediaText(nsAString& aMediaText)
|
|
{
|
|
GetText(aMediaText);
|
|
return NS_OK;
|
|
}
|
|
|
|
// "sheet" should be a CSSStyleSheet and "doc" should be an
|
|
// nsCOMPtr<nsIDocument>
|
|
#define BEGIN_MEDIA_CHANGE(sheet, doc) \
|
|
if (sheet) { \
|
|
doc = sheet->GetOwningDocument(); \
|
|
} \
|
|
mozAutoDocUpdate updateBatch(doc, UPDATE_STYLE, true); \
|
|
if (sheet) { \
|
|
sheet->WillDirty(); \
|
|
}
|
|
|
|
#define END_MEDIA_CHANGE(sheet, doc) \
|
|
if (sheet) { \
|
|
sheet->DidDirty(); \
|
|
} \
|
|
/* XXXldb Pass something meaningful? */ \
|
|
if (doc) { \
|
|
doc->StyleRuleChanged(sheet, nullptr); \
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::SetMediaText(const nsAString& aMediaText)
|
|
{
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
BEGIN_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
SetText(aMediaText);
|
|
|
|
END_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::GetLength(uint32_t* aLength)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aLength);
|
|
|
|
*aLength = Length();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::Item(uint32_t aIndex, nsAString& aReturn)
|
|
{
|
|
bool dummy;
|
|
IndexedGetter(aIndex, dummy, aReturn);
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsMediaList::IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aReturn)
|
|
{
|
|
if (aIndex < Length()) {
|
|
aFound = true;
|
|
aReturn.Truncate();
|
|
mArray[aIndex]->AppendToString(aReturn);
|
|
} else {
|
|
aFound = false;
|
|
SetDOMStringToNull(aReturn);
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::DeleteMedium(const nsAString& aOldMedium)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
BEGIN_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
rv = Delete(aOldMedium);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
END_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMediaList::AppendMedium(const nsAString& aNewMedium)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
nsCOMPtr<nsIDocument> doc;
|
|
|
|
BEGIN_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
rv = Append(aNewMedium);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
END_MEDIA_CHANGE(mStyleSheet, doc)
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult
|
|
nsMediaList::Delete(const nsAString& aOldMedium)
|
|
{
|
|
if (aOldMedium.IsEmpty())
|
|
return NS_ERROR_DOM_NOT_FOUND_ERR;
|
|
|
|
for (int32_t i = 0, i_end = mArray.Length(); i < i_end; ++i) {
|
|
nsMediaQuery* query = mArray[i];
|
|
|
|
nsAutoString buf;
|
|
query->AppendToString(buf);
|
|
if (buf == aOldMedium) {
|
|
mArray.RemoveElementAt(i);
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
return NS_ERROR_DOM_NOT_FOUND_ERR;
|
|
}
|
|
|
|
nsresult
|
|
nsMediaList::Append(const nsAString& aNewMedium)
|
|
{
|
|
if (aNewMedium.IsEmpty())
|
|
return NS_ERROR_DOM_NOT_FOUND_ERR;
|
|
|
|
Delete(aNewMedium);
|
|
|
|
nsresult rv = NS_OK;
|
|
nsTArray<nsAutoPtr<nsMediaQuery> > buf;
|
|
mArray.SwapElements(buf);
|
|
SetText(aNewMedium);
|
|
if (mArray.Length() == 1) {
|
|
nsMediaQuery *query = mArray[0].forget();
|
|
if (!buf.AppendElement(query)) {
|
|
delete query;
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
mArray.SwapElements(buf);
|
|
return rv;
|
|
}
|
|
|
|
namespace mozilla {
|
|
|
|
// -------------------------------
|
|
// CSS Style Sheet Inner Data Container
|
|
//
|
|
|
|
|
|
CSSStyleSheetInner::CSSStyleSheetInner(CSSStyleSheet* aPrimarySheet,
|
|
CORSMode aCORSMode,
|
|
ReferrerPolicy aReferrerPolicy,
|
|
const SRIMetadata& aIntegrity)
|
|
: mSheets()
|
|
, mCORSMode(aCORSMode)
|
|
, mReferrerPolicy (aReferrerPolicy)
|
|
, mIntegrity(aIntegrity)
|
|
, mComplete(false)
|
|
#ifdef DEBUG
|
|
, mPrincipalSet(false)
|
|
#endif
|
|
{
|
|
MOZ_COUNT_CTOR(CSSStyleSheetInner);
|
|
mSheets.AppendElement(aPrimarySheet);
|
|
|
|
mPrincipal = nsNullPrincipal::Create();
|
|
if (!mPrincipal) {
|
|
NS_RUNTIMEABORT("nsNullPrincipal::Init failed");
|
|
}
|
|
}
|
|
|
|
static bool SetStyleSheetReference(css::Rule* aRule, void* aSheet)
|
|
{
|
|
if (aRule) {
|
|
aRule->SetStyleSheet(static_cast<CSSStyleSheet*>(aSheet));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
struct ChildSheetListBuilder {
|
|
RefPtr<CSSStyleSheet>* sheetSlot;
|
|
CSSStyleSheet* parent;
|
|
|
|
void SetParentLinks(CSSStyleSheet* aSheet) {
|
|
aSheet->mParent = parent;
|
|
aSheet->SetOwningDocument(parent->mDocument);
|
|
}
|
|
|
|
static void ReparentChildList(CSSStyleSheet* aPrimarySheet,
|
|
CSSStyleSheet* aFirstChild)
|
|
{
|
|
for (CSSStyleSheet *child = aFirstChild; child; child = child->mNext) {
|
|
child->mParent = aPrimarySheet;
|
|
child->SetOwningDocument(aPrimarySheet->mDocument);
|
|
}
|
|
}
|
|
};
|
|
|
|
bool
|
|
CSSStyleSheet::RebuildChildList(css::Rule* aRule, void* aBuilder)
|
|
{
|
|
int32_t type = aRule->GetType();
|
|
if (type < css::Rule::IMPORT_RULE) {
|
|
// Keep going till we get to the import rules.
|
|
return true;
|
|
}
|
|
|
|
if (type != css::Rule::IMPORT_RULE) {
|
|
// We're past all the import rules; stop the enumeration.
|
|
return false;
|
|
}
|
|
|
|
ChildSheetListBuilder* builder =
|
|
static_cast<ChildSheetListBuilder*>(aBuilder);
|
|
|
|
// XXXbz We really need to decomtaminate all this stuff. Is there a reason
|
|
// that I can't just QI to ImportRule and get a CSSStyleSheet
|
|
// directly from it?
|
|
nsCOMPtr<nsIDOMCSSImportRule> importRule(do_QueryInterface(aRule));
|
|
NS_ASSERTION(importRule, "GetType lied");
|
|
|
|
nsCOMPtr<nsIDOMCSSStyleSheet> childSheet;
|
|
importRule->GetStyleSheet(getter_AddRefs(childSheet));
|
|
|
|
// Have to do this QI to be safe, since XPConnect can fake
|
|
// nsIDOMCSSStyleSheets
|
|
RefPtr<CSSStyleSheet> cssSheet = do_QueryObject(childSheet);
|
|
if (!cssSheet) {
|
|
return true;
|
|
}
|
|
|
|
(*builder->sheetSlot) = cssSheet;
|
|
builder->SetParentLinks(*builder->sheetSlot);
|
|
builder->sheetSlot = &(*builder->sheetSlot)->mNext;
|
|
return true;
|
|
}
|
|
|
|
size_t
|
|
CSSStyleSheet::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
size_t n = 0;
|
|
const CSSStyleSheet* s = this;
|
|
while (s) {
|
|
n += aMallocSizeOf(s);
|
|
|
|
// Each inner can be shared by multiple sheets. So we only count the inner
|
|
// if this sheet is the first one in the list of those sharing it. As a
|
|
// result, the first such sheet takes all the blame for the memory
|
|
// consumption of the inner, which isn't ideal but it's better than
|
|
// double-counting the inner.
|
|
if (s->mInner->mSheets[0] == s) {
|
|
n += s->mInner->SizeOfIncludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
// Measurement of the following members may be added later if DMD finds it
|
|
// is worthwhile:
|
|
// - s->mTitle
|
|
// - s->mMedia
|
|
// - s->mRuleCollection
|
|
// - s->mRuleProcessors
|
|
//
|
|
// The following members are not measured:
|
|
// - s->mOwnerRule, because it's non-owning
|
|
|
|
s = s->mNext;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
CSSStyleSheetInner::CSSStyleSheetInner(CSSStyleSheetInner& aCopy,
|
|
CSSStyleSheet* aPrimarySheet)
|
|
: mSheets(),
|
|
mSheetURI(aCopy.mSheetURI),
|
|
mOriginalSheetURI(aCopy.mOriginalSheetURI),
|
|
mBaseURI(aCopy.mBaseURI),
|
|
mPrincipal(aCopy.mPrincipal),
|
|
mCORSMode(aCopy.mCORSMode),
|
|
mReferrerPolicy(aCopy.mReferrerPolicy),
|
|
mIntegrity(aCopy.mIntegrity),
|
|
mComplete(aCopy.mComplete)
|
|
#ifdef DEBUG
|
|
, mPrincipalSet(aCopy.mPrincipalSet)
|
|
#endif
|
|
{
|
|
MOZ_COUNT_CTOR(CSSStyleSheetInner);
|
|
AddSheet(aPrimarySheet);
|
|
aCopy.mOrderedRules.EnumerateForwards(css::GroupRule::CloneRuleInto, &mOrderedRules);
|
|
mOrderedRules.EnumerateForwards(SetStyleSheetReference, aPrimarySheet);
|
|
|
|
ChildSheetListBuilder builder = { &mFirstChild, aPrimarySheet };
|
|
mOrderedRules.EnumerateForwards(CSSStyleSheet::RebuildChildList, &builder);
|
|
|
|
RebuildNameSpaces();
|
|
}
|
|
|
|
CSSStyleSheetInner::~CSSStyleSheetInner()
|
|
{
|
|
MOZ_COUNT_DTOR(CSSStyleSheetInner);
|
|
mOrderedRules.EnumerateForwards(SetStyleSheetReference, nullptr);
|
|
}
|
|
|
|
CSSStyleSheetInner*
|
|
CSSStyleSheetInner::CloneFor(CSSStyleSheet* aPrimarySheet)
|
|
{
|
|
return new CSSStyleSheetInner(*this, aPrimarySheet);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheetInner::AddSheet(CSSStyleSheet* aSheet)
|
|
{
|
|
mSheets.AppendElement(aSheet);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheetInner::RemoveSheet(CSSStyleSheet* aSheet)
|
|
{
|
|
if (1 == mSheets.Length()) {
|
|
NS_ASSERTION(aSheet == mSheets.ElementAt(0), "bad parent");
|
|
delete this;
|
|
return;
|
|
}
|
|
if (aSheet == mSheets.ElementAt(0)) {
|
|
mSheets.RemoveElementAt(0);
|
|
NS_ASSERTION(mSheets.Length(), "no parents");
|
|
mOrderedRules.EnumerateForwards(SetStyleSheetReference,
|
|
mSheets.ElementAt(0));
|
|
|
|
ChildSheetListBuilder::ReparentChildList(mSheets[0], mFirstChild);
|
|
}
|
|
else {
|
|
mSheets.RemoveElement(aSheet);
|
|
}
|
|
}
|
|
|
|
static void
|
|
AddNamespaceRuleToMap(css::Rule* aRule, nsXMLNameSpaceMap* aMap)
|
|
{
|
|
NS_ASSERTION(aRule->GetType() == css::Rule::NAMESPACE_RULE, "Bogus rule type");
|
|
|
|
RefPtr<css::NameSpaceRule> nameSpaceRule = do_QueryObject(aRule);
|
|
|
|
nsAutoString urlSpec;
|
|
nameSpaceRule->GetURLSpec(urlSpec);
|
|
|
|
aMap->AddPrefix(nameSpaceRule->GetPrefix(), urlSpec);
|
|
}
|
|
|
|
static bool
|
|
CreateNameSpace(css::Rule* aRule, void* aNameSpacePtr)
|
|
{
|
|
int32_t type = aRule->GetType();
|
|
if (css::Rule::NAMESPACE_RULE == type) {
|
|
AddNamespaceRuleToMap(aRule,
|
|
static_cast<nsXMLNameSpaceMap*>(aNameSpacePtr));
|
|
return true;
|
|
}
|
|
// stop if not namespace, import or charset because namespace can't follow
|
|
// anything else
|
|
return (css::Rule::CHARSET_RULE == type || css::Rule::IMPORT_RULE == type);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheetInner::RebuildNameSpaces()
|
|
{
|
|
// Just nuke our existing namespace map, if any
|
|
if (NS_SUCCEEDED(CreateNamespaceMap())) {
|
|
mOrderedRules.EnumerateForwards(CreateNameSpace, mNameSpaceMap);
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheetInner::CreateNamespaceMap()
|
|
{
|
|
mNameSpaceMap = nsXMLNameSpaceMap::Create(false);
|
|
NS_ENSURE_TRUE(mNameSpaceMap, NS_ERROR_OUT_OF_MEMORY);
|
|
// Override the default namespace map behavior for the null prefix to
|
|
// return the wildcard namespace instead of the null namespace.
|
|
mNameSpaceMap->AddPrefix(nullptr, kNameSpaceID_Unknown);
|
|
return NS_OK;
|
|
}
|
|
|
|
size_t
|
|
CSSStyleSheetInner::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
size_t n = aMallocSizeOf(this);
|
|
n += mOrderedRules.SizeOfExcludingThis(css::Rule::SizeOfCOMArrayElementIncludingThis,
|
|
aMallocSizeOf);
|
|
n += mFirstChild ? mFirstChild->SizeOfIncludingThis(aMallocSizeOf) : 0;
|
|
|
|
// Measurement of the following members may be added later if DMD finds it is
|
|
// worthwhile:
|
|
// - mSheetURI
|
|
// - mOriginalSheetURI
|
|
// - mBaseURI
|
|
// - mPrincipal
|
|
// - mNameSpaceMap
|
|
//
|
|
// The following members are not measured:
|
|
// - mSheets, because it's non-owning
|
|
|
|
return n;
|
|
}
|
|
|
|
// -------------------------------
|
|
// CSS Style Sheet
|
|
//
|
|
|
|
CSSStyleSheet::CSSStyleSheet(CORSMode aCORSMode, ReferrerPolicy aReferrerPolicy)
|
|
: mTitle(),
|
|
mParent(nullptr),
|
|
mOwnerRule(nullptr),
|
|
mDocument(nullptr),
|
|
mOwningNode(nullptr),
|
|
mDisabled(false),
|
|
mDirty(false),
|
|
mInRuleProcessorCache(false),
|
|
mParsingMode(css::eUserSheetFeatures),
|
|
mScopeElement(nullptr),
|
|
mRuleProcessors(nullptr)
|
|
{
|
|
mInner = new CSSStyleSheetInner(this, aCORSMode, aReferrerPolicy,
|
|
SRIMetadata());
|
|
}
|
|
|
|
CSSStyleSheet::CSSStyleSheet(CORSMode aCORSMode,
|
|
ReferrerPolicy aReferrerPolicy,
|
|
const SRIMetadata& aIntegrity)
|
|
: mTitle(),
|
|
mParent(nullptr),
|
|
mOwnerRule(nullptr),
|
|
mDocument(nullptr),
|
|
mOwningNode(nullptr),
|
|
mDisabled(false),
|
|
mDirty(false),
|
|
mInRuleProcessorCache(false),
|
|
mParsingMode(css::eUserSheetFeatures),
|
|
mScopeElement(nullptr),
|
|
mRuleProcessors(nullptr)
|
|
{
|
|
mInner = new CSSStyleSheetInner(this, aCORSMode, aReferrerPolicy,
|
|
aIntegrity);
|
|
}
|
|
|
|
CSSStyleSheet::CSSStyleSheet(const CSSStyleSheet& aCopy,
|
|
CSSStyleSheet* aParentToUse,
|
|
css::ImportRule* aOwnerRuleToUse,
|
|
nsIDocument* aDocumentToUse,
|
|
nsINode* aOwningNodeToUse)
|
|
: mTitle(aCopy.mTitle),
|
|
mParent(aParentToUse),
|
|
mOwnerRule(aOwnerRuleToUse),
|
|
mDocument(aDocumentToUse),
|
|
mOwningNode(aOwningNodeToUse),
|
|
mDisabled(aCopy.mDisabled),
|
|
mDirty(aCopy.mDirty),
|
|
mInRuleProcessorCache(false),
|
|
mParsingMode(aCopy.mParsingMode),
|
|
mScopeElement(nullptr),
|
|
mInner(aCopy.mInner),
|
|
mRuleProcessors(nullptr)
|
|
{
|
|
|
|
mInner->AddSheet(this);
|
|
|
|
if (mDirty) { // CSSOM's been there, force full copy now
|
|
NS_ASSERTION(mInner->mComplete, "Why have rules been accessed on an incomplete sheet?");
|
|
// FIXME: handle failure?
|
|
EnsureUniqueInner();
|
|
}
|
|
|
|
if (aCopy.mMedia) {
|
|
// XXX This is wrong; we should be keeping @import rules and
|
|
// sheets in sync!
|
|
mMedia = aCopy.mMedia->Clone();
|
|
}
|
|
}
|
|
|
|
CSSStyleSheet::~CSSStyleSheet()
|
|
{
|
|
for (CSSStyleSheet* child = mInner->mFirstChild;
|
|
child;
|
|
child = child->mNext) {
|
|
// XXXbz this is a little bogus; see the XXX comment where we
|
|
// declare mFirstChild.
|
|
if (child->mParent == this) {
|
|
child->mParent = nullptr;
|
|
child->mDocument = nullptr;
|
|
}
|
|
}
|
|
DropRuleCollection();
|
|
DropMedia();
|
|
mInner->RemoveSheet(this);
|
|
// XXX The document reference is not reference counted and should
|
|
// not be released. The document will let us know when it is going
|
|
// away.
|
|
if (mRuleProcessors) {
|
|
NS_ASSERTION(mRuleProcessors->Length() == 0, "destructing sheet with rule processor reference");
|
|
delete mRuleProcessors; // weak refs, should be empty here anyway
|
|
}
|
|
if (mInRuleProcessorCache) {
|
|
RuleProcessorCache::RemoveSheet(this);
|
|
}
|
|
}
|
|
|
|
mozilla::dom::CSSStyleSheetParsingMode
|
|
CSSStyleSheet::ParsingMode()
|
|
{
|
|
#define CHECK(X, Y) \
|
|
static_assert(static_cast<int>(X) == static_cast<int>(Y), \
|
|
"mozilla::dom::CSSStyleSheetParsingMode and mozilla::css::SheetParsingMode should have identical values");
|
|
|
|
CHECK(mozilla::dom::CSSStyleSheetParsingMode::Agent, css::eAgentSheetFeatures);
|
|
CHECK(mozilla::dom::CSSStyleSheetParsingMode::User, css::eUserSheetFeatures);
|
|
CHECK(mozilla::dom::CSSStyleSheetParsingMode::Author, css::eAuthorSheetFeatures);
|
|
|
|
#undef CHECK
|
|
|
|
return static_cast<mozilla::dom::CSSStyleSheetParsingMode>(mParsingMode);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::DropRuleCollection()
|
|
{
|
|
if (mRuleCollection) {
|
|
mRuleCollection->DropReference();
|
|
mRuleCollection = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::DropMedia()
|
|
{
|
|
if (mMedia) {
|
|
mMedia->SetStyleSheet(nullptr);
|
|
mMedia = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::UnlinkInner()
|
|
{
|
|
// We can only have a cycle through our inner if we have a unique inner,
|
|
// because otherwise there are no JS wrappers for anything in the inner.
|
|
if (mInner->mSheets.Length() != 1) {
|
|
return;
|
|
}
|
|
|
|
mInner->mOrderedRules.EnumerateForwards(SetStyleSheetReference, nullptr);
|
|
mInner->mOrderedRules.Clear();
|
|
|
|
// Have to be a bit careful with child sheets, because we want to
|
|
// drop their mNext pointers and null out their mParent and
|
|
// mDocument, but don't want to work with deleted objects. And we
|
|
// don't want to do any addrefing in the process, just to make sure
|
|
// we don't confuse the cycle collector (though on the face of it,
|
|
// addref/release pairs during unlink should probably be ok).
|
|
RefPtr<CSSStyleSheet> child;
|
|
child.swap(mInner->mFirstChild);
|
|
while (child) {
|
|
MOZ_ASSERT(child->mParent == this, "We have a unique inner!");
|
|
child->mParent = nullptr;
|
|
child->mDocument = nullptr;
|
|
RefPtr<CSSStyleSheet> next;
|
|
// Null out child->mNext, but don't let it die yet
|
|
next.swap(child->mNext);
|
|
// Switch to looking at the old value of child->mNext next iteration
|
|
child.swap(next);
|
|
// "next" is now our previous value of child; it'll get released
|
|
// as we loop around.
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::TraverseInner(nsCycleCollectionTraversalCallback &cb)
|
|
{
|
|
// We can only have a cycle through our inner if we have a unique inner,
|
|
// because otherwise there are no JS wrappers for anything in the inner.
|
|
if (mInner->mSheets.Length() != 1) {
|
|
return;
|
|
}
|
|
|
|
RefPtr<CSSStyleSheet>* childSheetSlot = &mInner->mFirstChild;
|
|
while (*childSheetSlot) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "child sheet");
|
|
cb.NoteXPCOMChild(NS_ISUPPORTS_CAST(nsIDOMCSSStyleSheet*, childSheetSlot->get()));
|
|
childSheetSlot = &(*childSheetSlot)->mNext;
|
|
}
|
|
|
|
const nsCOMArray<css::Rule>& rules = mInner->mOrderedRules;
|
|
for (int32_t i = 0, count = rules.Count(); i < count; ++i) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mOrderedRules[i]");
|
|
cb.NoteXPCOMChild(rules[i]->GetExistingDOMRule());
|
|
}
|
|
}
|
|
|
|
// QueryInterface implementation for CSSStyleSheet
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CSSStyleSheet)
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMStyleSheet)
|
|
NS_INTERFACE_MAP_ENTRY(nsIDOMCSSStyleSheet)
|
|
NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMCSSStyleSheet)
|
|
if (aIID.Equals(NS_GET_IID(CSSStyleSheet)))
|
|
foundInterface = reinterpret_cast<nsISupports*>(this);
|
|
else
|
|
NS_INTERFACE_MAP_END
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(CSSStyleSheet)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(CSSStyleSheet)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(CSSStyleSheet)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CSSStyleSheet)
|
|
tmp->DropMedia();
|
|
// We do not unlink mNext; our parent will handle that. If we
|
|
// unlinked it here, our parent would not be able to walk its list
|
|
// of child sheets and null out the back-references to it, if we got
|
|
// unlinked before it does.
|
|
tmp->DropRuleCollection();
|
|
tmp->UnlinkInner();
|
|
tmp->mScopeElement = nullptr;
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(CSSStyleSheet)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMedia)
|
|
// We do not traverse mNext; our parent will handle that. See
|
|
// comments in Unlink for why.
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRuleCollection)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScopeElement)
|
|
tmp->TraverseInner(cb);
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(CSSStyleSheet)
|
|
|
|
nsresult
|
|
CSSStyleSheet::AddRuleProcessor(nsCSSRuleProcessor* aProcessor)
|
|
{
|
|
if (! mRuleProcessors) {
|
|
mRuleProcessors = new nsAutoTArray<nsCSSRuleProcessor*, 8>();
|
|
if (!mRuleProcessors)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
NS_ASSERTION(mRuleProcessors->NoIndex == mRuleProcessors->IndexOf(aProcessor),
|
|
"processor already registered");
|
|
mRuleProcessors->AppendElement(aProcessor); // weak ref
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::DropRuleProcessor(nsCSSRuleProcessor* aProcessor)
|
|
{
|
|
if (!mRuleProcessors)
|
|
return NS_ERROR_FAILURE;
|
|
return mRuleProcessors->RemoveElement(aProcessor)
|
|
? NS_OK
|
|
: NS_ERROR_FAILURE;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::AddStyleSet(nsStyleSet* aStyleSet)
|
|
{
|
|
NS_ASSERTION(!mStyleSets.Contains(aStyleSet),
|
|
"style set already registered");
|
|
mStyleSets.AppendElement(aStyleSet);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::DropStyleSet(nsStyleSet* aStyleSet)
|
|
{
|
|
DebugOnly<bool> found = mStyleSets.RemoveElement(aStyleSet);
|
|
NS_ASSERTION(found, "didn't find style set");
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::SetURIs(nsIURI* aSheetURI, nsIURI* aOriginalSheetURI,
|
|
nsIURI* aBaseURI)
|
|
{
|
|
NS_PRECONDITION(aSheetURI && aBaseURI, "null ptr");
|
|
|
|
NS_ASSERTION(mInner->mOrderedRules.Count() == 0 && !mInner->mComplete,
|
|
"Can't call SetURL on sheets that are complete or have rules");
|
|
|
|
mInner->mSheetURI = aSheetURI;
|
|
mInner->mOriginalSheetURI = aOriginalSheetURI;
|
|
mInner->mBaseURI = aBaseURI;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::SetPrincipal(nsIPrincipal* aPrincipal)
|
|
{
|
|
NS_PRECONDITION(!mInner->mPrincipalSet,
|
|
"Should have an inner whose principal has not yet been set");
|
|
if (aPrincipal) {
|
|
mInner->mPrincipal = aPrincipal;
|
|
#ifdef DEBUG
|
|
mInner->mPrincipalSet = true;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
nsIURI*
|
|
CSSStyleSheet::GetSheetURI() const
|
|
{
|
|
return mInner->mSheetURI;
|
|
}
|
|
|
|
nsIURI*
|
|
CSSStyleSheet::GetBaseURI() const
|
|
{
|
|
return mInner->mBaseURI;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::GetType(nsString& aType) const
|
|
{
|
|
aType.AssignLiteral("text/css");
|
|
}
|
|
|
|
bool
|
|
CSSStyleSheet::UseForPresentation(nsPresContext* aPresContext,
|
|
nsMediaQueryResultCacheKey& aKey) const
|
|
{
|
|
if (mMedia) {
|
|
return mMedia->Matches(aPresContext, &aKey);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
void
|
|
CSSStyleSheet::SetMedia(nsMediaList* aMedia)
|
|
{
|
|
mMedia = aMedia;
|
|
}
|
|
|
|
bool
|
|
CSSStyleSheet::HasRules() const
|
|
{
|
|
return StyleRuleCount() != 0;
|
|
}
|
|
|
|
bool
|
|
CSSStyleSheet::IsApplicable() const
|
|
{
|
|
return !mDisabled && mInner->mComplete;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::SetEnabled(bool aEnabled)
|
|
{
|
|
// Internal method, so callers must handle BeginUpdate/EndUpdate
|
|
bool oldDisabled = mDisabled;
|
|
mDisabled = !aEnabled;
|
|
|
|
if (mInner->mComplete && oldDisabled != mDisabled) {
|
|
ClearRuleCascades();
|
|
|
|
if (mDocument) {
|
|
mDocument->SetStyleSheetApplicableState(this, !mDisabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
CSSStyleSheet::IsComplete() const
|
|
{
|
|
return mInner->mComplete;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::SetComplete()
|
|
{
|
|
NS_ASSERTION(!mDirty, "Can't set a dirty sheet complete!");
|
|
mInner->mComplete = true;
|
|
if (mDocument && !mDisabled) {
|
|
// Let the document know
|
|
mDocument->BeginUpdate(UPDATE_STYLE);
|
|
mDocument->SetStyleSheetApplicableState(this, true);
|
|
mDocument->EndUpdate(UPDATE_STYLE);
|
|
}
|
|
|
|
if (mOwningNode && !mDisabled &&
|
|
mOwningNode->HasFlag(NODE_IS_IN_SHADOW_TREE) &&
|
|
mOwningNode->IsContent()) {
|
|
ShadowRoot* shadowRoot = mOwningNode->AsContent()->GetContainingShadow();
|
|
shadowRoot->StyleSheetChanged();
|
|
}
|
|
}
|
|
|
|
CSSStyleSheet*
|
|
CSSStyleSheet::GetParentSheet() const
|
|
{
|
|
return mParent;
|
|
}
|
|
|
|
nsIDocument*
|
|
CSSStyleSheet::GetOwningDocument() const
|
|
{
|
|
return mDocument;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::SetOwningDocument(nsIDocument* aDocument)
|
|
{ // not ref counted
|
|
mDocument = aDocument;
|
|
// Now set the same document on all our child sheets....
|
|
// XXXbz this is a little bogus; see the XXX comment where we
|
|
// declare mFirstChild.
|
|
for (CSSStyleSheet* child = mInner->mFirstChild;
|
|
child; child = child->mNext) {
|
|
if (child->mParent == this) {
|
|
child->SetOwningDocument(aDocument);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint64_t
|
|
CSSStyleSheet::FindOwningWindowInnerID() const
|
|
{
|
|
uint64_t windowID = 0;
|
|
if (mDocument) {
|
|
windowID = mDocument->InnerWindowID();
|
|
}
|
|
|
|
if (windowID == 0 && mOwningNode) {
|
|
windowID = mOwningNode->OwnerDoc()->InnerWindowID();
|
|
}
|
|
|
|
if (windowID == 0 && mOwnerRule) {
|
|
RefPtr<CSSStyleSheet> sheet = static_cast<css::Rule*>(mOwnerRule)->GetStyleSheet();
|
|
if (sheet) {
|
|
windowID = sheet->FindOwningWindowInnerID();
|
|
}
|
|
}
|
|
|
|
if (windowID == 0 && mParent) {
|
|
windowID = mParent->FindOwningWindowInnerID();
|
|
}
|
|
|
|
return windowID;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::AppendStyleSheet(CSSStyleSheet* aSheet)
|
|
{
|
|
NS_PRECONDITION(nullptr != aSheet, "null arg");
|
|
|
|
WillDirty();
|
|
RefPtr<CSSStyleSheet>* tail = &mInner->mFirstChild;
|
|
while (*tail) {
|
|
tail = &(*tail)->mNext;
|
|
}
|
|
*tail = aSheet;
|
|
|
|
// This is not reference counted. Our parent tells us when
|
|
// it's going away.
|
|
aSheet->mParent = this;
|
|
aSheet->mDocument = mDocument;
|
|
DidDirty();
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::AppendStyleRule(css::Rule* aRule)
|
|
{
|
|
NS_PRECONDITION(nullptr != aRule, "null arg");
|
|
|
|
WillDirty();
|
|
mInner->mOrderedRules.AppendObject(aRule);
|
|
aRule->SetStyleSheet(this);
|
|
DidDirty();
|
|
|
|
if (css::Rule::NAMESPACE_RULE == aRule->GetType()) {
|
|
#ifdef DEBUG
|
|
nsresult rv =
|
|
#endif
|
|
RegisterNamespaceRule(aRule);
|
|
NS_WARN_IF_FALSE(NS_SUCCEEDED(rv),
|
|
"RegisterNamespaceRule returned error");
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
CSSStyleSheet::StyleRuleCount() const
|
|
{
|
|
return mInner->mOrderedRules.Count();
|
|
}
|
|
|
|
css::Rule*
|
|
CSSStyleSheet::GetStyleRuleAt(int32_t aIndex) const
|
|
{
|
|
// Important: If this function is ever made scriptable, we must add
|
|
// a security check here. See GetCssRules below for an example.
|
|
return mInner->mOrderedRules.SafeObjectAt(aIndex);
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::EnsureUniqueInner()
|
|
{
|
|
mDirty = true;
|
|
|
|
MOZ_ASSERT(mInner->mSheets.Length() != 0,
|
|
"unexpected number of outers");
|
|
if (mInner->mSheets.Length() == 1) {
|
|
// already unique
|
|
return;
|
|
}
|
|
CSSStyleSheetInner* clone = mInner->CloneFor(this);
|
|
MOZ_ASSERT(clone);
|
|
mInner->RemoveSheet(this);
|
|
mInner = clone;
|
|
|
|
// otherwise the rule processor has pointers to the old rules
|
|
ClearRuleCascades();
|
|
|
|
// let our containing style sets know that if we call
|
|
// nsPresContext::EnsureSafeToHandOutCSSRules we will need to restyle the
|
|
// document
|
|
for (nsStyleSet* styleSet : mStyleSets) {
|
|
styleSet->SetNeedsRestyleAfterEnsureUniqueInner();
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::AppendAllChildSheets(nsTArray<CSSStyleSheet*>& aArray)
|
|
{
|
|
for (CSSStyleSheet* child = mInner->mFirstChild; child;
|
|
child = child->mNext) {
|
|
aArray.AppendElement(child);
|
|
}
|
|
}
|
|
|
|
already_AddRefed<CSSStyleSheet>
|
|
CSSStyleSheet::Clone(CSSStyleSheet* aCloneParent,
|
|
css::ImportRule* aCloneOwnerRule,
|
|
nsIDocument* aCloneDocument,
|
|
nsINode* aCloneOwningNode) const
|
|
{
|
|
RefPtr<CSSStyleSheet> clone = new CSSStyleSheet(*this,
|
|
aCloneParent,
|
|
aCloneOwnerRule,
|
|
aCloneDocument,
|
|
aCloneOwningNode);
|
|
return clone.forget();
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
static void
|
|
ListRules(const nsCOMArray<css::Rule>& aRules, FILE* aOut, int32_t aIndent)
|
|
{
|
|
for (int32_t index = aRules.Count() - 1; index >= 0; --index) {
|
|
aRules.ObjectAt(index)->List(aOut, aIndent);
|
|
}
|
|
}
|
|
|
|
struct ListEnumData {
|
|
ListEnumData(FILE* aOut, int32_t aIndent)
|
|
: mOut(aOut),
|
|
mIndent(aIndent)
|
|
{
|
|
}
|
|
FILE* mOut;
|
|
int32_t mIndent;
|
|
};
|
|
|
|
void
|
|
CSSStyleSheet::List(FILE* out, int32_t aIndent) const
|
|
{
|
|
|
|
int32_t index;
|
|
|
|
// Indent
|
|
nsAutoCString str;
|
|
for (index = aIndent; --index >= 0; ) {
|
|
str.AppendLiteral(" ");
|
|
}
|
|
|
|
str.AppendLiteral("CSS Style Sheet: ");
|
|
nsAutoCString urlSpec;
|
|
nsresult rv = mInner->mSheetURI->GetSpec(urlSpec);
|
|
if (NS_SUCCEEDED(rv) && !urlSpec.IsEmpty()) {
|
|
str.Append(urlSpec);
|
|
}
|
|
|
|
if (mMedia) {
|
|
str.AppendLiteral(" media: ");
|
|
nsAutoString buffer;
|
|
mMedia->GetText(buffer);
|
|
AppendUTF16toUTF8(buffer, str);
|
|
}
|
|
str.Append('\n');
|
|
fprintf_stderr(out, "%s", str.get());
|
|
|
|
for (const CSSStyleSheet* child = mInner->mFirstChild;
|
|
child;
|
|
child = child->mNext) {
|
|
child->List(out, aIndent + 1);
|
|
}
|
|
|
|
fprintf_stderr(out, "%s", "Rules in source order:\n");
|
|
ListRules(mInner->mOrderedRules, out, aIndent);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
CSSStyleSheet::ClearRuleCascades()
|
|
{
|
|
// We might be in ClearRuleCascades because we had a modification
|
|
// to the sheet that resulted in an nsCSSSelector being destroyed.
|
|
// Tell the RestyleManager for each document we're used in
|
|
// so that they can drop any nsCSSSelector pointers (used for
|
|
// eRestyle_SomeDescendants) in their mPendingRestyles.
|
|
for (nsStyleSet* styleSet : mStyleSets) {
|
|
styleSet->ClearSelectors();
|
|
}
|
|
|
|
bool removedSheetFromRuleProcessorCache = false;
|
|
if (mRuleProcessors) {
|
|
nsCSSRuleProcessor **iter = mRuleProcessors->Elements(),
|
|
**end = iter + mRuleProcessors->Length();
|
|
for(; iter != end; ++iter) {
|
|
if (!removedSheetFromRuleProcessorCache && (*iter)->IsShared()) {
|
|
// Since the sheet has been modified, we need to remove all
|
|
// RuleProcessorCache entries that contain this sheet, as the
|
|
// list of @-moz-document rules might have changed.
|
|
RuleProcessorCache::RemoveSheet(this);
|
|
removedSheetFromRuleProcessorCache = true;
|
|
}
|
|
(*iter)->ClearRuleCascades();
|
|
}
|
|
}
|
|
if (mParent) {
|
|
CSSStyleSheet* parent = (CSSStyleSheet*)mParent;
|
|
parent->ClearRuleCascades();
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::WillDirty()
|
|
{
|
|
if (mInner->mComplete) {
|
|
EnsureUniqueInner();
|
|
}
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::DidDirty()
|
|
{
|
|
MOZ_ASSERT(!mInner->mComplete || mDirty,
|
|
"caller must have called WillDirty()");
|
|
ClearRuleCascades();
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::SubjectSubsumesInnerPrincipal()
|
|
{
|
|
nsCOMPtr<nsIPrincipal> subjectPrincipal = nsContentUtils::SubjectPrincipal();
|
|
if (subjectPrincipal->Subsumes(mInner->mPrincipal)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// Allow access only if CORS mode is not NONE
|
|
if (GetCORSMode() == CORS_NONE) {
|
|
return NS_ERROR_DOM_SECURITY_ERR;
|
|
}
|
|
|
|
// Now make sure we set the principal of our inner to the subjectPrincipal.
|
|
// We do this because we're in a situation where the caller would not normally
|
|
// be able to access the sheet, but the sheet has opted in to being read.
|
|
// Unfortunately, that means it's also opted in to being _edited_, and if the
|
|
// caller now makes edits to the sheet we want the resulting resource loads,
|
|
// if any, to look as if they are coming from the caller's principal, not the
|
|
// original sheet principal.
|
|
//
|
|
// That means we need a unique inner, of course. But we don't want to do that
|
|
// if we're not complete yet. Luckily, all the callers of this method throw
|
|
// anyway if not complete, so we can just do that here too.
|
|
if (!mInner->mComplete) {
|
|
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
|
|
}
|
|
|
|
WillDirty();
|
|
|
|
mInner->mPrincipal = subjectPrincipal;
|
|
|
|
DidDirty();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::RegisterNamespaceRule(css::Rule* aRule)
|
|
{
|
|
if (!mInner->mNameSpaceMap) {
|
|
nsresult rv = mInner->CreateNamespaceMap();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
AddNamespaceRuleToMap(aRule, mInner->mNameSpaceMap);
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsIDOMStyleSheet interface
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetType(nsAString& aType)
|
|
{
|
|
aType.AssignLiteral("text/css");
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetDisabled(bool* aDisabled)
|
|
{
|
|
*aDisabled = Disabled();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::SetDisabled(bool aDisabled)
|
|
{
|
|
// DOM method, so handle BeginUpdate/EndUpdate
|
|
MOZ_AUTO_DOC_UPDATE(mDocument, UPDATE_STYLE, true);
|
|
CSSStyleSheet::SetEnabled(!aDisabled);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetOwnerNode(nsIDOMNode** aOwnerNode)
|
|
{
|
|
nsCOMPtr<nsIDOMNode> ownerNode = do_QueryInterface(GetOwnerNode());
|
|
ownerNode.forget(aOwnerNode);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetParentStyleSheet(nsIDOMStyleSheet** aParentStyleSheet)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aParentStyleSheet);
|
|
|
|
NS_IF_ADDREF(*aParentStyleSheet = mParent);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetHref(nsAString& aHref)
|
|
{
|
|
if (mInner->mOriginalSheetURI) {
|
|
nsAutoCString str;
|
|
mInner->mOriginalSheetURI->GetSpec(str);
|
|
CopyUTF8toUTF16(str, aHref);
|
|
} else {
|
|
SetDOMStringToNull(aHref);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
CSSStyleSheet::GetTitle(nsString& aTitle) const
|
|
{
|
|
aTitle = mTitle;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetTitle(nsAString& aTitle)
|
|
{
|
|
aTitle.Assign(mTitle);
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetMedia(nsIDOMMediaList** aMedia)
|
|
{
|
|
NS_ADDREF(*aMedia = Media());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsMediaList*
|
|
CSSStyleSheet::Media()
|
|
{
|
|
if (!mMedia) {
|
|
mMedia = new nsMediaList();
|
|
mMedia->SetStyleSheet(this);
|
|
}
|
|
|
|
return mMedia;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetOwnerRule(nsIDOMCSSRule** aOwnerRule)
|
|
{
|
|
NS_IF_ADDREF(*aOwnerRule = GetOwnerRule());
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIDOMCSSRule*
|
|
CSSStyleSheet::GetDOMOwnerRule() const
|
|
{
|
|
return mOwnerRule ? mOwnerRule->GetDOMRule() : nullptr;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::GetCssRules(nsIDOMCSSRuleList** aCssRules)
|
|
{
|
|
ErrorResult rv;
|
|
nsCOMPtr<nsIDOMCSSRuleList> rules = GetCssRules(rv);
|
|
rules.forget(aCssRules);
|
|
return rv.StealNSResult();
|
|
}
|
|
|
|
CSSRuleList*
|
|
CSSStyleSheet::GetCssRules(ErrorResult& aRv)
|
|
{
|
|
// No doing this on incomplete sheets!
|
|
if (!mInner->mComplete) {
|
|
aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
|
|
return nullptr;
|
|
}
|
|
|
|
//-- Security check: Only scripts whose principal subsumes that of the
|
|
// style sheet can access rule collections.
|
|
nsresult rv = SubjectSubsumesInnerPrincipal();
|
|
if (NS_FAILED(rv)) {
|
|
aRv.Throw(rv);
|
|
return nullptr;
|
|
}
|
|
|
|
// OK, security check passed, so get the rule collection
|
|
if (!mRuleCollection) {
|
|
mRuleCollection = new CSSRuleListImpl(this);
|
|
}
|
|
|
|
return mRuleCollection;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::InsertRule(const nsAString& aRule,
|
|
uint32_t aIndex,
|
|
uint32_t* aReturn)
|
|
{
|
|
//-- Security check: Only scripts whose principal subsumes that of the
|
|
// style sheet can modify rule collections.
|
|
nsresult rv = SubjectSubsumesInnerPrincipal();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return InsertRuleInternal(aRule, aIndex, aReturn);
|
|
}
|
|
|
|
static bool
|
|
RuleHasPendingChildSheet(css::Rule *cssRule)
|
|
{
|
|
nsCOMPtr<nsIDOMCSSImportRule> importRule(do_QueryInterface(cssRule));
|
|
NS_ASSERTION(importRule, "Rule which has type IMPORT_RULE and does not implement nsIDOMCSSImportRule!");
|
|
nsCOMPtr<nsIDOMCSSStyleSheet> childSheet;
|
|
importRule->GetStyleSheet(getter_AddRefs(childSheet));
|
|
RefPtr<CSSStyleSheet> cssSheet = do_QueryObject(childSheet);
|
|
return cssSheet != nullptr && !cssSheet->IsComplete();
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::InsertRuleInternal(const nsAString& aRule,
|
|
uint32_t aIndex,
|
|
uint32_t* aReturn)
|
|
{
|
|
// No doing this if the sheet is not complete!
|
|
if (!mInner->mComplete) {
|
|
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
|
|
}
|
|
|
|
WillDirty();
|
|
|
|
if (aIndex > uint32_t(mInner->mOrderedRules.Count()))
|
|
return NS_ERROR_DOM_INDEX_SIZE_ERR;
|
|
|
|
NS_ASSERTION(uint32_t(mInner->mOrderedRules.Count()) <= INT32_MAX,
|
|
"Too many style rules!");
|
|
|
|
// Hold strong ref to the CSSLoader in case the document update
|
|
// kills the document
|
|
RefPtr<css::Loader> loader;
|
|
if (mDocument) {
|
|
loader = mDocument->CSSLoader();
|
|
NS_ASSERTION(loader, "Document with no CSS loader!");
|
|
}
|
|
|
|
nsCSSParser css(loader, this);
|
|
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
RefPtr<css::Rule> rule;
|
|
nsresult result = css.ParseRule(aRule, mInner->mSheetURI, mInner->mBaseURI,
|
|
mInner->mPrincipal, getter_AddRefs(rule));
|
|
if (NS_FAILED(result))
|
|
return result;
|
|
|
|
// Hierarchy checking.
|
|
int32_t newType = rule->GetType();
|
|
|
|
// check that we're not inserting before a charset rule
|
|
css::Rule* nextRule = mInner->mOrderedRules.SafeObjectAt(aIndex);
|
|
if (nextRule) {
|
|
int32_t nextType = nextRule->GetType();
|
|
if (nextType == css::Rule::CHARSET_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
|
|
if (nextType == css::Rule::IMPORT_RULE &&
|
|
newType != css::Rule::CHARSET_RULE &&
|
|
newType != css::Rule::IMPORT_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
|
|
if (nextType == css::Rule::NAMESPACE_RULE &&
|
|
newType != css::Rule::CHARSET_RULE &&
|
|
newType != css::Rule::IMPORT_RULE &&
|
|
newType != css::Rule::NAMESPACE_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
}
|
|
|
|
if (aIndex != 0) {
|
|
// no inserting charset at nonzero position
|
|
if (newType == css::Rule::CHARSET_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
|
|
css::Rule* prevRule = mInner->mOrderedRules.SafeObjectAt(aIndex - 1);
|
|
int32_t prevType = prevRule->GetType();
|
|
|
|
if (newType == css::Rule::IMPORT_RULE &&
|
|
prevType != css::Rule::CHARSET_RULE &&
|
|
prevType != css::Rule::IMPORT_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
|
|
if (newType == css::Rule::NAMESPACE_RULE &&
|
|
prevType != css::Rule::CHARSET_RULE &&
|
|
prevType != css::Rule::IMPORT_RULE &&
|
|
prevType != css::Rule::NAMESPACE_RULE) {
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
}
|
|
|
|
bool insertResult = mInner->mOrderedRules.InsertObjectAt(rule, aIndex);
|
|
NS_ENSURE_TRUE(insertResult, NS_ERROR_OUT_OF_MEMORY);
|
|
DidDirty();
|
|
|
|
rule->SetStyleSheet(this);
|
|
|
|
int32_t type = rule->GetType();
|
|
if (type == css::Rule::NAMESPACE_RULE) {
|
|
// XXXbz does this screw up when inserting a namespace rule before
|
|
// another namespace rule that binds the same prefix to a different
|
|
// namespace?
|
|
result = RegisterNamespaceRule(rule);
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
}
|
|
|
|
// We don't notify immediately for @import rules, but rather when
|
|
// the sheet the rule is importing is loaded (see StyleSheetLoaded)
|
|
if ((type != css::Rule::IMPORT_RULE || !RuleHasPendingChildSheet(rule)) &&
|
|
mDocument) {
|
|
mDocument->StyleRuleAdded(this, rule);
|
|
}
|
|
|
|
*aReturn = aIndex;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::DeleteRule(uint32_t aIndex)
|
|
{
|
|
// No doing this if the sheet is not complete!
|
|
if (!mInner->mComplete) {
|
|
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
|
|
}
|
|
|
|
//-- Security check: Only scripts whose principal subsumes that of the
|
|
// style sheet can modify rule collections.
|
|
nsresult rv = SubjectSubsumesInnerPrincipal();
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// XXX TBI: handle @rule types
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
WillDirty();
|
|
|
|
if (aIndex >= uint32_t(mInner->mOrderedRules.Count()))
|
|
return NS_ERROR_DOM_INDEX_SIZE_ERR;
|
|
|
|
NS_ASSERTION(uint32_t(mInner->mOrderedRules.Count()) <= INT32_MAX,
|
|
"Too many style rules!");
|
|
|
|
// Hold a strong ref to the rule so it doesn't die when we RemoveObjectAt
|
|
RefPtr<css::Rule> rule = mInner->mOrderedRules.ObjectAt(aIndex);
|
|
if (rule) {
|
|
mInner->mOrderedRules.RemoveObjectAt(aIndex);
|
|
if (mDocument && mDocument->StyleSheetChangeEventsEnabled()) {
|
|
// Force creation of the DOM rule, so that it can be put on the
|
|
// StyleRuleRemoved event object.
|
|
rule->GetDOMRule();
|
|
}
|
|
rule->SetStyleSheet(nullptr);
|
|
DidDirty();
|
|
|
|
if (mDocument) {
|
|
mDocument->StyleRuleRemoved(this, rule);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::DeleteRuleFromGroup(css::GroupRule* aGroup, uint32_t aIndex)
|
|
{
|
|
NS_ENSURE_ARG_POINTER(aGroup);
|
|
NS_ASSERTION(mInner->mComplete, "No deleting from an incomplete sheet!");
|
|
RefPtr<css::Rule> rule = aGroup->GetStyleRuleAt(aIndex);
|
|
NS_ENSURE_TRUE(rule, NS_ERROR_ILLEGAL_VALUE);
|
|
|
|
// check that the rule actually belongs to this sheet!
|
|
if (this != rule->GetStyleSheet()) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
WillDirty();
|
|
|
|
nsresult result = aGroup->DeleteStyleRuleAt(aIndex);
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
|
|
rule->SetStyleSheet(nullptr);
|
|
|
|
DidDirty();
|
|
|
|
if (mDocument) {
|
|
mDocument->StyleRuleRemoved(this, rule);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::InsertRuleIntoGroup(const nsAString & aRule,
|
|
css::GroupRule* aGroup,
|
|
uint32_t aIndex,
|
|
uint32_t* _retval)
|
|
{
|
|
NS_ASSERTION(mInner->mComplete, "No inserting into an incomplete sheet!");
|
|
// check that the group actually belongs to this sheet!
|
|
if (this != aGroup->GetStyleSheet()) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
// Hold strong ref to the CSSLoader in case the document update
|
|
// kills the document
|
|
RefPtr<css::Loader> loader;
|
|
if (mDocument) {
|
|
loader = mDocument->CSSLoader();
|
|
NS_ASSERTION(loader, "Document with no CSS loader!");
|
|
}
|
|
|
|
nsCSSParser css(loader, this);
|
|
|
|
// parse and grab the rule
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
WillDirty();
|
|
|
|
RefPtr<css::Rule> rule;
|
|
nsresult result = css.ParseRule(aRule, mInner->mSheetURI, mInner->mBaseURI,
|
|
mInner->mPrincipal, getter_AddRefs(rule));
|
|
if (NS_FAILED(result))
|
|
return result;
|
|
|
|
switch (rule->GetType()) {
|
|
case css::Rule::STYLE_RULE:
|
|
case css::Rule::MEDIA_RULE:
|
|
case css::Rule::FONT_FACE_RULE:
|
|
case css::Rule::PAGE_RULE:
|
|
case css::Rule::KEYFRAMES_RULE:
|
|
case css::Rule::COUNTER_STYLE_RULE:
|
|
case css::Rule::DOCUMENT_RULE:
|
|
case css::Rule::SUPPORTS_RULE:
|
|
// these types are OK to insert into a group
|
|
break;
|
|
case css::Rule::CHARSET_RULE:
|
|
case css::Rule::IMPORT_RULE:
|
|
case css::Rule::NAMESPACE_RULE:
|
|
// these aren't
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
default:
|
|
NS_NOTREACHED("unexpected rule type");
|
|
return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
|
|
}
|
|
|
|
result = aGroup->InsertStyleRuleAt(aIndex, rule);
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
DidDirty();
|
|
|
|
if (mDocument) {
|
|
mDocument->StyleRuleAdded(this, rule);
|
|
}
|
|
|
|
*_retval = aIndex;
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsICSSLoaderObserver implementation
|
|
NS_IMETHODIMP
|
|
CSSStyleSheet::StyleSheetLoaded(CSSStyleSheet* aSheet,
|
|
bool aWasAlternate,
|
|
nsresult aStatus)
|
|
{
|
|
if (aSheet->GetParentSheet() == nullptr) {
|
|
return NS_OK; // ignore if sheet has been detached already (see parseSheet)
|
|
}
|
|
NS_ASSERTION(this == aSheet->GetParentSheet(),
|
|
"We are being notified of a sheet load for a sheet that is not our child!");
|
|
|
|
if (mDocument && NS_SUCCEEDED(aStatus)) {
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
// XXXldb @import rules shouldn't even implement nsIStyleRule (but
|
|
// they do)!
|
|
mDocument->StyleRuleAdded(this, aSheet->GetOwnerRule());
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
CSSStyleSheet::ReparseSheet(const nsAString& aInput)
|
|
{
|
|
// Not doing this if the sheet is not complete!
|
|
if (!mInner->mComplete) {
|
|
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
|
|
}
|
|
|
|
// Hold strong ref to the CSSLoader in case the document update
|
|
// kills the document
|
|
RefPtr<css::Loader> loader;
|
|
if (mDocument) {
|
|
loader = mDocument->CSSLoader();
|
|
NS_ASSERTION(loader, "Document with no CSS loader!");
|
|
} else {
|
|
loader = new css::Loader();
|
|
}
|
|
|
|
mozAutoDocUpdate updateBatch(mDocument, UPDATE_STYLE, true);
|
|
|
|
WillDirty();
|
|
|
|
// detach existing rules (including child sheets via import rules)
|
|
css::LoaderReusableStyleSheets reusableSheets;
|
|
int ruleCount;
|
|
while ((ruleCount = mInner->mOrderedRules.Count()) != 0) {
|
|
RefPtr<css::Rule> rule = mInner->mOrderedRules.ObjectAt(ruleCount - 1);
|
|
mInner->mOrderedRules.RemoveObjectAt(ruleCount - 1);
|
|
rule->SetStyleSheet(nullptr);
|
|
if (rule->GetType() == css::Rule::IMPORT_RULE) {
|
|
nsCOMPtr<nsIDOMCSSImportRule> importRule(do_QueryInterface(rule));
|
|
NS_ASSERTION(importRule, "GetType lied");
|
|
|
|
nsCOMPtr<nsIDOMCSSStyleSheet> childSheet;
|
|
importRule->GetStyleSheet(getter_AddRefs(childSheet));
|
|
|
|
RefPtr<CSSStyleSheet> cssSheet = do_QueryObject(childSheet);
|
|
if (cssSheet && cssSheet->GetOriginalURI()) {
|
|
reusableSheets.AddReusableSheet(cssSheet);
|
|
}
|
|
}
|
|
if (mDocument) {
|
|
mDocument->StyleRuleRemoved(this, rule);
|
|
}
|
|
}
|
|
|
|
// nuke child sheets list and current namespace map
|
|
for (CSSStyleSheet* child = mInner->mFirstChild; child; ) {
|
|
NS_ASSERTION(child->mParent == this, "Child sheet is not parented to this!");
|
|
CSSStyleSheet* next = child->mNext;
|
|
child->mParent = nullptr;
|
|
child->mDocument = nullptr;
|
|
child->mNext = nullptr;
|
|
child = next;
|
|
}
|
|
mInner->mFirstChild = nullptr;
|
|
mInner->mNameSpaceMap = nullptr;
|
|
|
|
uint32_t lineNumber = 1;
|
|
if (mOwningNode) {
|
|
nsCOMPtr<nsIStyleSheetLinkingElement> link = do_QueryInterface(mOwningNode);
|
|
if (link) {
|
|
lineNumber = link->GetLineNumber();
|
|
}
|
|
}
|
|
|
|
nsCSSParser parser(loader, this);
|
|
nsresult rv = parser.ParseSheet(aInput, mInner->mSheetURI, mInner->mBaseURI,
|
|
mInner->mPrincipal, lineNumber,
|
|
mParsingMode, &reusableSheets);
|
|
DidDirty(); // we are always 'dirty' here since we always remove rules first
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// notify document of all new rules
|
|
if (mDocument) {
|
|
for (int32_t index = 0; index < mInner->mOrderedRules.Count(); ++index) {
|
|
RefPtr<css::Rule> rule = mInner->mOrderedRules.ObjectAt(index);
|
|
if (rule->GetType() == css::Rule::IMPORT_RULE &&
|
|
RuleHasPendingChildSheet(rule)) {
|
|
continue; // notify when loaded (see StyleSheetLoaded)
|
|
}
|
|
mDocument->StyleRuleAdded(this, rule);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
/* virtual */
|
|
JSObject*
|
|
CSSStyleSheet::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return CSSStyleSheetBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
} // namespace mozilla
|