2016-11-22 23:26:20 +00:00
|
|
|
/* -*- 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/. */
|
|
|
|
|
|
|
|
/* representation of CSSRuleList for stylo */
|
|
|
|
|
|
|
|
#include "mozilla/ServoCSSRuleList.h"
|
|
|
|
|
2018-06-05 00:07:25 +00:00
|
|
|
#include "mozilla/dom/CSSCounterStyleRule.h"
|
2018-06-04 23:55:11 +00:00
|
|
|
#include "mozilla/dom/CSSFontFaceRule.h"
|
2018-09-07 14:47:51 +00:00
|
|
|
#include "mozilla/dom/CSSFontFeatureValuesRule.h"
|
2018-06-06 13:31:33 +00:00
|
|
|
#include "mozilla/dom/CSSImportRule.h"
|
2018-06-04 10:09:11 +00:00
|
|
|
#include "mozilla/dom/CSSKeyframesRule.h"
|
2018-06-04 12:14:47 +00:00
|
|
|
#include "mozilla/dom/CSSMediaRule.h"
|
2018-06-05 15:16:51 +00:00
|
|
|
#include "mozilla/dom/CSSMozDocumentRule.h"
|
2018-06-01 10:35:39 +00:00
|
|
|
#include "mozilla/dom/CSSNamespaceRule.h"
|
2018-06-05 11:39:42 +00:00
|
|
|
#include "mozilla/dom/CSSPageRule.h"
|
2018-06-04 13:35:50 +00:00
|
|
|
#include "mozilla/dom/CSSStyleRule.h"
|
2018-06-05 13:17:08 +00:00
|
|
|
#include "mozilla/dom/CSSSupportsRule.h"
|
2017-05-30 01:10:25 +00:00
|
|
|
#include "mozilla/IntegerRange.h"
|
2016-11-22 23:26:20 +00:00
|
|
|
#include "mozilla/ServoBindings.h"
|
2018-04-30 17:23:14 +00:00
|
|
|
#include "mozilla/StyleSheet.h"
|
2019-01-02 13:05:23 +00:00
|
|
|
#include "mozilla/dom/Document.h"
|
2016-11-22 23:26:20 +00:00
|
|
|
|
2018-02-13 00:53:44 +00:00
|
|
|
using namespace mozilla::dom;
|
|
|
|
|
2016-11-22 23:26:20 +00:00
|
|
|
namespace mozilla {
|
|
|
|
|
2017-05-30 01:10:25 +00:00
|
|
|
ServoCSSRuleList::ServoCSSRuleList(already_AddRefed<ServoCssRules> aRawRules,
|
2018-06-29 02:56:09 +00:00
|
|
|
StyleSheet* aSheet,
|
|
|
|
css::GroupRule* aParentRule)
|
|
|
|
: mStyleSheet(aSheet), mParentRule(aParentRule), mRawRules(aRawRules) {
|
2016-11-22 23:26:20 +00:00
|
|
|
Servo_CssRules_ListTypes(mRawRules, &mRules);
|
|
|
|
}
|
|
|
|
|
2017-01-06 04:14:28 +00:00
|
|
|
// QueryInterface implementation for ServoCSSRuleList
|
2017-08-29 23:02:48 +00:00
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServoCSSRuleList)
|
2017-01-06 04:14:28 +00:00
|
|
|
NS_INTERFACE_MAP_END_INHERITING(dom::CSSRuleList)
|
|
|
|
|
|
|
|
NS_IMPL_ADDREF_INHERITED(ServoCSSRuleList, dom::CSSRuleList)
|
|
|
|
NS_IMPL_RELEASE_INHERITED(ServoCSSRuleList, dom::CSSRuleList)
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(ServoCSSRuleList)
|
|
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ServoCSSRuleList)
|
2017-03-09 09:53:34 +00:00
|
|
|
tmp->DropAllRules();
|
2017-01-06 04:14:28 +00:00
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(dom::CSSRuleList)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ServoCSSRuleList,
|
|
|
|
dom::CSSRuleList)
|
|
|
|
tmp->EnumerateInstantiatedRules([&](css::Rule* aRule) {
|
2016-11-30 23:18:14 +00:00
|
|
|
if (!aRule->IsCCLeaf()) {
|
|
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mRules[i]");
|
|
|
|
cb.NoteXPCOMChild(aRule);
|
|
|
|
}
|
2017-01-06 04:14:28 +00:00
|
|
|
});
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
|
2016-11-29 11:59:55 +00:00
|
|
|
css::Rule* ServoCSSRuleList::GetRule(uint32_t aIndex) {
|
2016-11-22 23:26:20 +00:00
|
|
|
uintptr_t rule = mRules[aIndex];
|
|
|
|
if (rule <= kMaxRuleType) {
|
|
|
|
RefPtr<css::Rule> ruleObj = nullptr;
|
|
|
|
switch (rule) {
|
2017-03-14 06:52:37 +00:00
|
|
|
#define CASE_RULE(const_, name_) \
|
2018-06-29 02:56:09 +00:00
|
|
|
case CSSRule_Binding::const_##_RULE: { \
|
2018-06-01 10:35:39 +00:00
|
|
|
uint32_t line = 0, column = 0; \
|
|
|
|
RefPtr<RawServo##name_##Rule> rule = \
|
|
|
|
Servo_CssRules_Get##name_##RuleAt(mRawRules, aIndex, &line, &column) \
|
|
|
|
.Consume(); \
|
|
|
|
MOZ_ASSERT(rule); \
|
2018-06-29 02:56:09 +00:00
|
|
|
ruleObj = new CSS##name_##Rule(rule.forget(), mStyleSheet, mParentRule, \
|
|
|
|
line, column); \
|
2018-06-01 10:35:39 +00:00
|
|
|
break; \
|
|
|
|
}
|
2018-06-06 14:26:28 +00:00
|
|
|
CASE_RULE(STYLE, Style)
|
|
|
|
CASE_RULE(KEYFRAMES, Keyframes)
|
|
|
|
CASE_RULE(MEDIA, Media)
|
|
|
|
CASE_RULE(NAMESPACE, Namespace)
|
|
|
|
CASE_RULE(PAGE, Page)
|
|
|
|
CASE_RULE(SUPPORTS, Supports)
|
|
|
|
CASE_RULE(DOCUMENT, MozDocument)
|
|
|
|
CASE_RULE(IMPORT, Import)
|
|
|
|
CASE_RULE(FONT_FEATURE_VALUES, FontFeatureValues)
|
|
|
|
CASE_RULE(FONT_FACE, FontFace)
|
|
|
|
CASE_RULE(COUNTER_STYLE, CounterStyle)
|
2017-03-14 06:52:37 +00:00
|
|
|
#undef CASE_RULE
|
2018-06-25 21:20:54 +00:00
|
|
|
case CSSRule_Binding::KEYFRAME_RULE:
|
2017-05-19 06:12:34 +00:00
|
|
|
MOZ_ASSERT_UNREACHABLE("keyframe rule cannot be here");
|
|
|
|
return nullptr;
|
2016-11-22 23:26:20 +00:00
|
|
|
default:
|
2017-02-14 01:19:54 +00:00
|
|
|
NS_WARNING("stylo: not implemented yet");
|
2016-11-24 05:28:28 +00:00
|
|
|
return nullptr;
|
2016-11-22 23:26:20 +00:00
|
|
|
}
|
|
|
|
rule = CastToUint(ruleObj.forget().take());
|
|
|
|
mRules[aIndex] = rule;
|
|
|
|
}
|
2016-11-29 11:59:55 +00:00
|
|
|
return CastToPtr(rule);
|
|
|
|
}
|
|
|
|
|
|
|
|
css::Rule* ServoCSSRuleList::IndexedGetter(uint32_t aIndex, bool& aFound) {
|
|
|
|
if (aIndex >= mRules.Length()) {
|
|
|
|
aFound = false;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
aFound = true;
|
2017-01-13 15:41:03 +00:00
|
|
|
return GetRule(aIndex);
|
2016-11-22 23:26:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Func>
|
|
|
|
void ServoCSSRuleList::EnumerateInstantiatedRules(Func aCallback) {
|
|
|
|
for (uintptr_t rule : mRules) {
|
|
|
|
if (rule > kMaxRuleType) {
|
|
|
|
aCallback(CastToPtr(rule));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-09 09:53:34 +00:00
|
|
|
static void DropRule(already_AddRefed<css::Rule> aRule) {
|
|
|
|
RefPtr<css::Rule> rule = aRule;
|
2018-06-29 02:56:09 +00:00
|
|
|
rule->DropReferences();
|
2017-03-09 09:53:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ServoCSSRuleList::DropAllRules() {
|
2018-06-29 02:56:09 +00:00
|
|
|
mStyleSheet = nullptr;
|
|
|
|
mParentRule = nullptr;
|
2016-11-22 23:26:20 +00:00
|
|
|
EnumerateInstantiatedRules(
|
2017-03-09 09:53:34 +00:00
|
|
|
[](css::Rule* rule) { DropRule(already_AddRefed<css::Rule>(rule)); });
|
|
|
|
mRules.Clear();
|
Bug 1345696 part 6 - Fix cycle collection for font-face rule. r=heycam,mccr8
Having Servo's FontFaceRule owning Gecko's nsCSSFontFaceRule object opens an
untracked edge, because we generally don't track the reference through Servo
objects, so there is a chance that nsCSSFontFaceRule can form a undroppable
reference cycle.
This patch adds a workaround that we track @font-face rule twice in CSS rule
list. This is not perfect, but the idea is that, if someone wants to put some
reference on the @font-face rule, the rule itself and its parent list should
have been constructed in the CSSOM tree. If they are not there, we are
probably safe from cycle reference.
For @font-face rule, that assumption isn't strictly true. Script can still
get a font-face rule via layout inspector's nsIDOMFontFace::rule. If some
script puts an object which references the stylesheet of the rule or any of
its parent rule / rule list into font-face rule's expando, we would leak
again... But as far as that is an internal interface, we are probably safe?
MozReview-Commit-ID: DDMJh3mxDCH
--HG--
extra : rebase_source : 646fcf076195151e6890ebffb7597e58c8a7d522
2017-03-28 05:11:44 +00:00
|
|
|
mRawRules = nullptr;
|
2017-03-09 09:53:34 +00:00
|
|
|
}
|
|
|
|
|
2018-06-29 02:56:09 +00:00
|
|
|
void ServoCSSRuleList::DropSheetReference() {
|
|
|
|
// If mStyleSheet is not set on this rule list, then it is not set on any of
|
|
|
|
// its instantiated rules either. To avoid O(N^2) beavhior in the depth of
|
|
|
|
// group rule nesting, which can happen if we are unlinked starting from the
|
|
|
|
// deepest nested group rule, skip recursing into the rule list if we know we
|
|
|
|
// don't need to.
|
|
|
|
if (!mStyleSheet) {
|
|
|
|
return;
|
|
|
|
}
|
2017-03-09 09:53:34 +00:00
|
|
|
mStyleSheet = nullptr;
|
2018-06-29 02:56:09 +00:00
|
|
|
EnumerateInstantiatedRules(
|
|
|
|
[](css::Rule* rule) { rule->DropSheetReference(); });
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServoCSSRuleList::DropParentRuleReference() {
|
2017-03-09 09:53:34 +00:00
|
|
|
mParentRule = nullptr;
|
2018-06-29 02:56:09 +00:00
|
|
|
EnumerateInstantiatedRules(
|
|
|
|
[](css::Rule* rule) { rule->DropParentRuleReference(); });
|
2016-11-22 23:26:20 +00:00
|
|
|
}
|
|
|
|
|
2016-11-29 11:59:55 +00:00
|
|
|
nsresult ServoCSSRuleList::InsertRule(const nsAString& aRule, uint32_t aIndex) {
|
2017-04-03 10:04:32 +00:00
|
|
|
MOZ_ASSERT(mStyleSheet,
|
|
|
|
"Caller must ensure that "
|
|
|
|
"the list is not unlinked from stylesheet");
|
2019-04-29 05:34:06 +00:00
|
|
|
|
|
|
|
if (IsReadOnly()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-11-29 11:59:55 +00:00
|
|
|
NS_ConvertUTF16toUTF8 rule(aRule);
|
2017-03-09 09:53:34 +00:00
|
|
|
bool nested = !!mParentRule;
|
2017-04-03 10:04:32 +00:00
|
|
|
css::Loader* loader = nullptr;
|
2019-03-14 22:30:37 +00:00
|
|
|
|
|
|
|
// TODO(emilio, bug 1535456): Should probably always be able to get a handle
|
|
|
|
// to some loader if we're parsing an @import rule, but which one?
|
|
|
|
//
|
|
|
|
// StyleSheet::ReparseSheet just mints a new loader, but that'd be wrong in
|
|
|
|
// this case I think, since such a load will bypass CSP checks.
|
2019-01-02 13:05:23 +00:00
|
|
|
if (Document* doc = mStyleSheet->GetAssociatedDocument()) {
|
2017-04-03 10:04:32 +00:00
|
|
|
loader = doc->CSSLoader();
|
|
|
|
}
|
2016-11-29 11:59:55 +00:00
|
|
|
uint16_t type;
|
2017-06-29 01:07:06 +00:00
|
|
|
nsresult rv =
|
|
|
|
Servo_CssRules_InsertRule(mRawRules, mStyleSheet->RawContents(), &rule,
|
2017-04-03 10:04:32 +00:00
|
|
|
aIndex, nested, loader, mStyleSheet, &type);
|
2017-05-30 01:10:25 +00:00
|
|
|
if (NS_FAILED(rv)) {
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
mRules.InsertElementAt(aIndex, type);
|
2016-11-29 11:59:55 +00:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult ServoCSSRuleList::DeleteRule(uint32_t aIndex) {
|
2019-04-29 05:34:06 +00:00
|
|
|
if (IsReadOnly()) {
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2016-11-29 11:59:55 +00:00
|
|
|
nsresult rv = Servo_CssRules_DeleteRule(mRawRules, aIndex);
|
|
|
|
if (!NS_FAILED(rv)) {
|
2017-02-08 03:19:08 +00:00
|
|
|
uintptr_t rule = mRules[aIndex];
|
|
|
|
if (rule > kMaxRuleType) {
|
2017-03-09 09:53:34 +00:00
|
|
|
DropRule(already_AddRefed<css::Rule>(CastToPtr(rule)));
|
2017-02-08 03:19:08 +00:00
|
|
|
}
|
2016-11-29 11:59:55 +00:00
|
|
|
mRules.RemoveElementAt(aIndex);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2017-09-06 23:58:42 +00:00
|
|
|
uint16_t ServoCSSRuleList::GetDOMCSSRuleType(uint32_t aIndex) const {
|
2017-04-03 09:55:06 +00:00
|
|
|
uintptr_t rule = mRules[aIndex];
|
|
|
|
if (rule <= kMaxRuleType) {
|
|
|
|
return rule;
|
|
|
|
}
|
|
|
|
return CastToPtr(rule)->Type();
|
|
|
|
}
|
|
|
|
|
2016-11-22 23:26:20 +00:00
|
|
|
ServoCSSRuleList::~ServoCSSRuleList() {
|
2017-11-28 23:06:51 +00:00
|
|
|
MOZ_ASSERT(!mStyleSheet, "Backpointer should have been cleared");
|
|
|
|
MOZ_ASSERT(!mParentRule, "Backpointer should have been cleared");
|
2017-03-09 09:53:34 +00:00
|
|
|
DropAllRules();
|
2016-11-22 23:26:20 +00:00
|
|
|
}
|
|
|
|
|
2019-04-29 05:34:06 +00:00
|
|
|
bool ServoCSSRuleList::IsReadOnly() const {
|
|
|
|
MOZ_ASSERT(!mStyleSheet || !mParentRule ||
|
|
|
|
mStyleSheet->IsReadOnly() == mParentRule->IsReadOnly(),
|
|
|
|
"a parent rule should be read only iff the owning sheet is "
|
|
|
|
"read only");
|
|
|
|
return mStyleSheet && mStyleSheet->IsReadOnly();
|
|
|
|
}
|
|
|
|
|
2016-11-22 23:26:20 +00:00
|
|
|
} // namespace mozilla
|