layout/style/ServoCSSRuleList.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 /* representation of CSSRuleList for stylo */
   8
   9 #include "mozilla/ServoCSSRuleList.h"
  10
  11 #include "mozilla/dom/CSSCounterStyleRule.h"
  12 #include "mozilla/dom/CSSFontFaceRule.h"
  13 #include "mozilla/dom/CSSFontFeatureValuesRule.h"
  14 #include "mozilla/dom/CSSFontPaletteValuesRule.h"
  15 #include "mozilla/dom/CSSImportRule.h"
  16 #include "mozilla/dom/CSSLayerBlockRule.h"
  17 #include "mozilla/dom/CSSLayerStatementRule.h"
  18 #include "mozilla/dom/CSSKeyframesRule.h"
  19 #include "mozilla/dom/CSSContainerRule.h"
  20 #include "mozilla/dom/CSSMediaRule.h"
  21 #include "mozilla/dom/CSSMozDocumentRule.h"
  22 #include "mozilla/dom/CSSNamespaceRule.h"
  23 #include "mozilla/dom/CSSPageRule.h"
  24 #include "mozilla/dom/CSSPropertyRule.h"
  25 #include "mozilla/dom/CSSStyleRule.h"
  26 #include "mozilla/dom/CSSSupportsRule.h"
  27 #include "mozilla/IntegerRange.h"
  28 #include "mozilla/ServoBindings.h"
  29 #include "mozilla/StyleSheet.h"
  30 #include "mozilla/dom/Document.h"
  31
  32 using namespace mozilla::dom;
  33
  34 namespace mozilla {
  35
  36 ServoCSSRuleList::ServoCSSRuleList(
  37     already_AddRefed<StyleLockedCssRules> aRawRules, StyleSheet* aSheet,
  38     css::GroupRule* aParentRule)
  39     : mStyleSheet(aSheet), mParentRule(aParentRule), mRawRules(aRawRules) {
  40   ResetRules();
  41 }
  42
  43 // QueryInterface implementation for ServoCSSRuleList
  44 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ServoCSSRuleList)
  45 NS_INTERFACE_MAP_END_INHERITING(dom::CSSRuleList)
  46
  47 NS_IMPL_ADDREF_INHERITED(ServoCSSRuleList, dom::CSSRuleList)
  48 NS_IMPL_RELEASE_INHERITED(ServoCSSRuleList, dom::CSSRuleList)
  49
  50 NS_IMPL_CYCLE_COLLECTION_CLASS(ServoCSSRuleList)
  51
  52 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ServoCSSRuleList)
  53   tmp->DropAllRules();
  54 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(dom::CSSRuleList)
  55 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ServoCSSRuleList,
  56                                                   dom::CSSRuleList)
  57   tmp->EnumerateInstantiatedRules([&](css::Rule* aRule, uint32_t) {
  58     if (!aRule->IsCCLeaf()) {
  59       NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mRules[i]");
  60       cb.NoteXPCOMChild(aRule);
  61     }
  62   });
  63 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  64
  65 css::Rule* ServoCSSRuleList::GetRule(uint32_t aIndex) {
  66   uintptr_t rule = mRules[aIndex];
  67   if (rule <= kMaxRuleType) {
  68     RefPtr<css::Rule> ruleObj = nullptr;
  69     switch (StyleCssRuleType(rule)) {
  70 #define CASE_RULE_WITH_PREFIX(const_, prefix_, name_)                         \
  71   case StyleCssRuleType::const_: {                                            \
  72     uint32_t line = 0, column = 0;                                            \
  73     RefPtr<Style##prefix_##const_##Rule> raw =                                \
  74         Servo_CssRules_Get##const_##RuleAt(mRawRules, aIndex, &line, &column) \
  75             .Consume();                                                       \
  76     MOZ_ASSERT(raw);                                                          \
  77     ruleObj = new CSS##name_##Rule(raw.forget(), mStyleSheet, mParentRule,    \
  78                                    line, column);                             \
  79     MOZ_ASSERT(ruleObj->Type() == StyleCssRuleType(rule));                    \
  80     break;                                                                    \
  81   }
  82 #define CASE_RULE_LOCKED(const_, name_) \
  83   CASE_RULE_WITH_PREFIX(const_, Locked, name_)
  84 #define CASE_RULE_UNLOCKED(const_, name_) CASE_RULE_WITH_PREFIX(const_, , name_)
  85       CASE_RULE_LOCKED(Style, Style)
  86       CASE_RULE_LOCKED(Keyframes, Keyframes)
  87       CASE_RULE_UNLOCKED(Media, Media)
  88       CASE_RULE_UNLOCKED(Namespace, Namespace)
  89       CASE_RULE_LOCKED(Page, Page)
  90       CASE_RULE_UNLOCKED(Property, Property)
  91       CASE_RULE_UNLOCKED(Supports, Supports)
  92       CASE_RULE_UNLOCKED(Document, MozDocument)
  93       CASE_RULE_LOCKED(Import, Import)
  94       CASE_RULE_UNLOCKED(FontFeatureValues, FontFeatureValues)
  95       CASE_RULE_UNLOCKED(FontPaletteValues, FontPaletteValues)
  96       CASE_RULE_LOCKED(FontFace, FontFace)
  97       CASE_RULE_LOCKED(CounterStyle, CounterStyle)
  98       CASE_RULE_UNLOCKED(LayerBlock, LayerBlock)
  99       CASE_RULE_UNLOCKED(LayerStatement, LayerStatement)
 100       CASE_RULE_UNLOCKED(Container, Container)
 101 #undef CASE_RULE_LOCKED
 102 #undef CASE_RULE_UNLOCKED
 103 #undef CASE_RULE_WITH_PREFIX
 104       case StyleCssRuleType::Keyframe:
 105         MOZ_ASSERT_UNREACHABLE("keyframe rule cannot be here");
 106         return nullptr;
 107       case StyleCssRuleType::Margin:
 108         // Margin rules not implemented yet, see bug 1864737
 109         return nullptr;
 110     }
 111     rule = CastToUint(ruleObj.forget().take());
 112     mRules[aIndex] = rule;
 113   }
 114   return CastToPtr(rule);
 115 }
 116
 117 css::Rule* ServoCSSRuleList::IndexedGetter(uint32_t aIndex, bool& aFound) {
 118   if (aIndex >= mRules.Length()) {
 119     aFound = false;
 120     return nullptr;
 121   }
 122   aFound = true;
 123   return GetRule(aIndex);
 124 }
 125
 126 template <typename Func>
 127 void ServoCSSRuleList::EnumerateInstantiatedRules(Func aCallback) {
 128   uint32_t index = 0;
 129   for (uintptr_t rule : mRules) {
 130     if (rule > kMaxRuleType) {
 131       aCallback(CastToPtr(rule), index);
 132     }
 133     index++;
 134   }
 135 }
 136
 137 static void DropRule(already_AddRefed<css::Rule> aRule) {
 138   RefPtr<css::Rule> rule = aRule;
 139   rule->DropReferences();
 140 }
 141
 142 void ServoCSSRuleList::ResetRules() {
 143   // DropRule could reenter here via the cycle collector.
 144   auto rules = std::move(mRules);
 145   for (uintptr_t rule : rules) {
 146     if (rule > kMaxRuleType) {
 147       DropRule(already_AddRefed<css::Rule>(CastToPtr(rule)));
 148     }
 149   }
 150   MOZ_ASSERT(mRules.IsEmpty());
 151   if (mRawRules) {
 152     Servo_CssRules_ListTypes(mRawRules, &mRules);
 153   }
 154 }
 155
 156 void ServoCSSRuleList::DropAllRules() {
 157   mStyleSheet = nullptr;
 158   mParentRule = nullptr;
 159   mRawRules = nullptr;
 160
 161   ResetRules();
 162 }
 163
 164 void ServoCSSRuleList::DropSheetReference() {
 165   // If mStyleSheet is not set on this rule list, then it is not set on any of
 166   // its instantiated rules either.  To avoid O(N^2) beavhior in the depth of
 167   // group rule nesting, which can happen if we are unlinked starting from the
 168   // deepest nested group rule, skip recursing into the rule list if we know we
 169   // don't need to.
 170   if (!mStyleSheet) {
 171     return;
 172   }
 173   mStyleSheet = nullptr;
 174   EnumerateInstantiatedRules(
 175       [](css::Rule* rule, uint32_t) { rule->DropSheetReference(); });
 176 }
 177
 178 void ServoCSSRuleList::DropParentRuleReference() {
 179   mParentRule = nullptr;
 180   EnumerateInstantiatedRules(
 181       [](css::Rule* rule, uint32_t) { rule->DropParentRuleReference(); });
 182 }
 183
 184 nsresult ServoCSSRuleList::InsertRule(const nsACString& aRule,
 185                                       uint32_t aIndex) {
 186   MOZ_ASSERT(mStyleSheet,
 187              "Caller must ensure that "
 188              "the list is not unlinked from stylesheet");
 189
 190   if (!mRawRules || IsReadOnly()) {
 191     return NS_OK;
 192   }
 193
 194   mStyleSheet->WillDirty();
 195
 196   css::Loader* loader = nullptr;
 197   auto allowImportRules = mStyleSheet->SelfOrAncestorIsConstructed()
 198                               ? StyleAllowImportRules::No
 199                               : StyleAllowImportRules::Yes;
 200
 201   // TODO(emilio, bug 1535456): Should probably always be able to get a handle
 202   // to some loader if we're parsing an @import rule, but which one?
 203   //
 204   // StyleSheet::ReparseSheet just mints a new loader, but that'd be wrong in
 205   // this case I think, since such a load will bypass CSP checks.
 206   if (Document* doc = mStyleSheet->GetAssociatedDocument()) {
 207     loader = doc->CSSLoader();
 208   }
 209   StyleCssRuleType type;
 210   uint32_t containingTypes = 0;
 211   for (css::Rule* rule = mParentRule; rule; rule = rule->GetParentRule()) {
 212     containingTypes |= (1 << uint32_t(rule->Type()));
 213   }
 214   nsresult rv = Servo_CssRules_InsertRule(
 215       mRawRules, mStyleSheet->RawContents(), &aRule, aIndex, containingTypes,
 216       loader, allowImportRules, mStyleSheet, &type);
 217   NS_ENSURE_SUCCESS(rv, rv);
 218   mRules.InsertElementAt(aIndex, uintptr_t(type));
 219   return rv;
 220 }
 221
 222 nsresult ServoCSSRuleList::DeleteRule(uint32_t aIndex) {
 223   if (!mRawRules || IsReadOnly()) {
 224     return NS_OK;
 225   }
 226
 227   nsresult rv = Servo_CssRules_DeleteRule(mRawRules, aIndex);
 228   if (!NS_FAILED(rv)) {
 229     uintptr_t rule = mRules[aIndex];
 230     mRules.RemoveElementAt(aIndex);
 231     if (rule > kMaxRuleType) {
 232       DropRule(already_AddRefed<css::Rule>(CastToPtr(rule)));
 233     }
 234   }
 235   return rv;
 236 }
 237
 238 void ServoCSSRuleList::SetRawContents(RefPtr<StyleLockedCssRules> aNewRules,
 239                                       bool aFromClone) {
 240   mRawRules = std::move(aNewRules);
 241   if (!aFromClone) {
 242     ResetRules();
 243     return;
 244   }
 245
 246   EnumerateInstantiatedRules([&](css::Rule* aRule, uint32_t aIndex) {
 247 #define RULE_CASE_WITH_PREFIX(constant_, prefix_, type_)                \
 248   case StyleCssRuleType::constant_: {                                   \
 249     uint32_t line = 0, column = 0;                                      \
 250     RefPtr<Style##prefix_##constant_##Rule> raw =                       \
 251         Servo_CssRules_Get##constant_##RuleAt(mRawRules, aIndex, &line, \
 252                                               &column)                  \
 253             .Consume();                                                 \
 254     static_cast<dom::CSS##type_##Rule*>(aRule)->SetRawAfterClone(       \
 255         std::move(raw));                                                \
 256     break;                                                              \
 257   }
 258 #define RULE_CASE_LOCKED(constant_, type_) \
 259   RULE_CASE_WITH_PREFIX(constant_, Locked, type_)
 260 #define RULE_CASE_UNLOCKED(constant_, type_) \
 261   RULE_CASE_WITH_PREFIX(constant_, , type_)
 262     switch (aRule->Type()) {
 263       RULE_CASE_LOCKED(Style, Style)
 264       RULE_CASE_LOCKED(Keyframes, Keyframes)
 265       RULE_CASE_UNLOCKED(Media, Media)
 266       RULE_CASE_UNLOCKED(Namespace, Namespace)
 267       RULE_CASE_LOCKED(Page, Page)
 268       RULE_CASE_UNLOCKED(Property, Property)
 269       RULE_CASE_UNLOCKED(Supports, Supports)
 270       RULE_CASE_UNLOCKED(Document, MozDocument)
 271       RULE_CASE_LOCKED(Import, Import)
 272       RULE_CASE_UNLOCKED(FontFeatureValues, FontFeatureValues)
 273       RULE_CASE_UNLOCKED(FontPaletteValues, FontPaletteValues)
 274       RULE_CASE_LOCKED(FontFace, FontFace)
 275       RULE_CASE_LOCKED(CounterStyle, CounterStyle)
 276       RULE_CASE_UNLOCKED(LayerBlock, LayerBlock)
 277       RULE_CASE_UNLOCKED(LayerStatement, LayerStatement)
 278       RULE_CASE_UNLOCKED(Container, Container)
 279       case StyleCssRuleType::Keyframe:
 280         MOZ_ASSERT_UNREACHABLE("keyframe rule cannot be here");
 281         break;
 282       case StyleCssRuleType::Margin:
 283         // Margin rules not implemented yet, see bug 1864737
 284         break;
 285     }
 286 #undef RULE_CASE_WITH_PREFIX
 287 #undef RULE_CASE_LOCKED
 288 #undef RULE_CASE_UNLOCKED
 289   });
 290 }
 291
 292 ServoCSSRuleList::~ServoCSSRuleList() {
 293   MOZ_ASSERT(!mStyleSheet, "Backpointer should have been cleared");
 294   MOZ_ASSERT(!mParentRule, "Backpointer should have been cleared");
 295   DropAllRules();
 296 }
 297
 298 bool ServoCSSRuleList::IsReadOnly() const {
 299   MOZ_ASSERT(!mStyleSheet || !mParentRule ||
 300                  mStyleSheet->IsReadOnly() == mParentRule->IsReadOnly(),
 301              "a parent rule should be read only iff the owning sheet is "
 302              "read only");
 303   return mStyleSheet && mStyleSheet->IsReadOnly();
 304 }
 305
 306 }  // namespace mozilla