layout/style/CSSStyleRule.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 #include "mozilla/dom/CSSStyleRule.h"
   8 #include "mozilla/dom/CSSStyleRuleBinding.h"
   9
  10 #include "mozilla/CSSEnabledState.h"
  11 #include "mozilla/DeclarationBlock.h"
  12 #include "mozilla/PseudoStyleType.h"
  13 #include "mozilla/ServoBindings.h"
  14 #include "mozilla/dom/ShadowRoot.h"
  15 #include "nsCSSPseudoElements.h"
  16
  17 #include "nsISupports.h"
  18
  19 namespace mozilla::dom {
  20
  21 // -- CSSStyleRuleDeclaration ---------------------------------------
  22
  23 CSSStyleRuleDeclaration::CSSStyleRuleDeclaration(
  24     already_AddRefed<StyleLockedDeclarationBlock> aDecls)
  25     : mDecls(new DeclarationBlock(std::move(aDecls))) {
  26   mDecls->SetOwningRule(Rule());
  27 }
  28
  29 CSSStyleRuleDeclaration::~CSSStyleRuleDeclaration() {
  30   mDecls->SetOwningRule(nullptr);
  31 }
  32
  33 // QueryInterface implementation for CSSStyleRuleDeclaration
  34 NS_INTERFACE_MAP_BEGIN(CSSStyleRuleDeclaration)
  35   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  36   // We forward the cycle collection interfaces to Rule(), which is
  37   // never null (in fact, we're part of that object!)
  38   if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) ||
  39       aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant))) {
  40     return Rule()->QueryInterface(aIID, aInstancePtr);
  41   }
  42 NS_INTERFACE_MAP_END_INHERITING(nsDOMCSSDeclaration)
  43
  44 NS_IMPL_ADDREF_USING_AGGREGATOR(CSSStyleRuleDeclaration, Rule())
  45 NS_IMPL_RELEASE_USING_AGGREGATOR(CSSStyleRuleDeclaration, Rule())
  46
  47 /* nsDOMCSSDeclaration implementation */
  48
  49 css::Rule* CSSStyleRuleDeclaration::GetParentRule() { return Rule(); }
  50
  51 nsINode* CSSStyleRuleDeclaration::GetAssociatedNode() const {
  52   return Rule()->GetAssociatedDocumentOrShadowRoot();
  53 }
  54
  55 nsISupports* CSSStyleRuleDeclaration::GetParentObject() const {
  56   return Rule()->GetParentObject();
  57 }
  58
  59 DeclarationBlock* CSSStyleRuleDeclaration::GetOrCreateCSSDeclaration(
  60     Operation aOperation, DeclarationBlock** aCreated) {
  61   if (aOperation != Operation::Read) {
  62     if (StyleSheet* sheet = Rule()->GetStyleSheet()) {
  63       sheet->WillDirty();
  64     }
  65   }
  66   return mDecls;
  67 }
  68
  69 void CSSStyleRuleDeclaration::SetRawAfterClone(
  70     RefPtr<StyleLockedDeclarationBlock> aRaw) {
  71   auto block = MakeRefPtr<DeclarationBlock>(aRaw.forget());
  72   mDecls->SetOwningRule(nullptr);
  73   mDecls = std::move(block);
  74   mDecls->SetOwningRule(Rule());
  75 }
  76
  77 void CSSStyleRule::SetRawAfterClone(RefPtr<StyleLockedStyleRule> aRaw) {
  78   mRawRule = std::move(aRaw);
  79   mDecls.SetRawAfterClone(Servo_StyleRule_GetStyle(mRawRule).Consume());
  80   GroupRule::DidSetRawAfterClone();
  81 }
  82
  83 already_AddRefed<StyleLockedCssRules> CSSStyleRule::GetOrCreateRawRules() {
  84   return Servo_StyleRule_EnsureRules(mRawRule, IsReadOnly()).Consume();
  85 }
  86
  87 nsresult CSSStyleRuleDeclaration::SetCSSDeclaration(
  88     DeclarationBlock* aDecl, MutationClosureData* aClosureData) {
  89   CSSStyleRule* rule = Rule();
  90
  91   if (StyleSheet* sheet = rule->GetStyleSheet()) {
  92     if (aDecl != mDecls) {
  93       mDecls->SetOwningRule(nullptr);
  94       RefPtr<DeclarationBlock> decls = aDecl;
  95       Servo_StyleRule_SetStyle(rule->Raw(), decls->Raw());
  96       mDecls = std::move(decls);
  97       mDecls->SetOwningRule(rule);
  98     }
  99     sheet->RuleChanged(rule, StyleRuleChangeKind::StyleRuleDeclarations);
 100   }
 101   return NS_OK;
 102 }
 103
 104 nsDOMCSSDeclaration::ParsingEnvironment
 105 CSSStyleRuleDeclaration::GetParsingEnvironment(nsIPrincipal*) const {
 106   return GetParsingEnvironmentForRule(Rule(), StyleCssRuleType::Style);
 107 }
 108
 109 // -- CSSStyleRule --------------------------------------------------
 110
 111 CSSStyleRule::CSSStyleRule(already_AddRefed<StyleLockedStyleRule> aRawRule,
 112                            StyleSheet* aSheet, css::Rule* aParentRule,
 113                            uint32_t aLine, uint32_t aColumn)
 114     : GroupRule(aSheet, aParentRule, aLine, aColumn),
 115       mRawRule(aRawRule),
 116       mDecls(Servo_StyleRule_GetStyle(mRawRule).Consume()) {}
 117
 118 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(CSSStyleRule, GroupRule)
 119
 120 NS_IMPL_CYCLE_COLLECTION_CLASS(CSSStyleRule)
 121
 122 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(CSSStyleRule, GroupRule)
 123   // Keep this in sync with IsCCLeaf.
 124
 125   // Trace the wrapper for our declaration.  This just expands out
 126   // NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER which we can't use
 127   // directly because the wrapper is on the declaration, not on us.
 128   tmp->mDecls.TraceWrapper(aCallbacks, aClosure);
 129 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 130
 131 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CSSStyleRule)
 132   // Keep this in sync with IsCCLeaf.
 133
 134   // Unlink the wrapper for our declaration.
 135   //
 136   // Note that this has to happen before unlinking css::Rule.
 137   tmp->UnlinkDeclarationWrapper(tmp->mDecls);
 138   NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR
 139 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(GroupRule)
 140
 141 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSStyleRule, GroupRule)
 142   // Keep this in sync with IsCCLeaf.
 143 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 144
 145 bool CSSStyleRule::IsCCLeaf() const {
 146   if (!GroupRule::IsCCLeaf()) {
 147     return false;
 148   }
 149   return !mDecls.PreservingWrapper();
 150 }
 151
 152 size_t CSSStyleRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
 153   size_t n = aMallocSizeOf(this);
 154
 155   // Measurement of the following members may be added later if DMD finds it
 156   // is worthwhile:
 157   // - mRawRule
 158   // - mDecls
 159
 160   return n;
 161 }
 162
 163 #ifdef DEBUG
 164 void CSSStyleRule::List(FILE* out, int32_t aIndent) const {
 165   nsAutoCString str;
 166   for (int32_t i = 0; i < aIndent; i++) {
 167     str.AppendLiteral("  ");
 168   }
 169   Servo_StyleRule_Debug(mRawRule, &str);
 170   fprintf_stderr(out, "%s\n", str.get());
 171 }
 172 #endif
 173
 174 /* CSSRule implementation */
 175
 176 StyleCssRuleType CSSStyleRule::Type() const { return StyleCssRuleType::Style; }
 177
 178 void CSSStyleRule::GetCssText(nsACString& aCssText) const {
 179   Servo_StyleRule_GetCssText(mRawRule, &aCssText);
 180 }
 181
 182 /* CSSStyleRule implementation */
 183
 184 StyleLockedDeclarationBlock* CSSStyleRule::RawStyle() const {
 185   return mDecls.mDecls->Raw();
 186 }
 187
 188 void CSSStyleRule::GetSelectorText(nsACString& aSelectorText) {
 189   Servo_StyleRule_GetSelectorText(mRawRule, &aSelectorText);
 190 }
 191
 192 void CSSStyleRule::SetSelectorText(const nsACString& aSelectorText) {
 193   if (IsReadOnly()) {
 194     return;
 195   }
 196
 197   StyleSheet* sheet = GetStyleSheet();
 198   if (!sheet) {
 199     return;
 200   }
 201   sheet->WillDirty();
 202
 203   auto state = ContainingRuleState::From(mParentRule);
 204
 205   // TODO(emilio): May actually be more efficient to handle this as rule
 206   // removal + addition, from the point of view of invalidation...
 207   const StyleStylesheetContents* contents = sheet->RawContents();
 208   if (Servo_StyleRule_SetSelectorText(
 209           contents, mRawRule, &aSelectorText,
 210           state.mParseRelativeType.ptrOr(nullptr))) {
 211     sheet->RuleChanged(this, StyleRuleChangeKind::Generic);
 212   }
 213 }
 214
 215 uint32_t CSSStyleRule::SelectorCount() const {
 216   return Servo_StyleRule_GetSelectorCount(mRawRule);
 217 }
 218
 219 static void CollectStyleRules(CSSStyleRule& aDeepestRule, bool aDesugared,
 220                               nsTArray<const StyleLockedStyleRule*>& aResult) {
 221   aResult.AppendElement(aDeepestRule.Raw());
 222   if (aDesugared) {
 223     for (auto* rule = aDeepestRule.GetParentRule(); rule;
 224          rule = rule->GetParentRule()) {
 225       if (rule->Type() == StyleCssRuleType::Style) {
 226         aResult.AppendElement(static_cast<CSSStyleRule*>(rule)->Raw());
 227       }
 228     }
 229   }
 230 }
 231
 232 void CSSStyleRule::GetSelectorDataAtIndex(uint32_t aSelectorIndex,
 233                                           bool aDesugared, nsACString* aText,
 234                                           uint64_t* aSpecificity) {
 235   AutoTArray<const StyleLockedStyleRule*, 8> rules;
 236   CollectStyleRules(*this, aDesugared, rules);
 237   Servo_StyleRule_GetSelectorDataAtIndex(&rules, aSelectorIndex, aText,
 238                                          aSpecificity);
 239 }
 240
 241 void CSSStyleRule::SelectorTextAt(uint32_t aSelectorIndex, bool aDesugared,
 242                                   nsACString& aText) {
 243   GetSelectorDataAtIndex(aSelectorIndex, aDesugared, &aText, nullptr);
 244 }
 245
 246 uint64_t CSSStyleRule::SelectorSpecificityAt(uint32_t aSelectorIndex,
 247                                              bool aDesugared) {
 248   uint64_t s = 0;
 249   GetSelectorDataAtIndex(aSelectorIndex, aDesugared, nullptr, &s);
 250   return s;
 251 }
 252
 253 bool CSSStyleRule::SelectorMatchesElement(uint32_t aSelectorIndex,
 254                                           Element& aElement,
 255                                           const nsAString& aPseudo,
 256                                           bool aRelevantLinkVisited) {
 257   Maybe<PseudoStyleType> pseudoType = nsCSSPseudoElements::GetPseudoType(
 258       aPseudo, CSSEnabledState::IgnoreEnabledState);
 259   if (!pseudoType) {
 260     return false;
 261   }
 262
 263   auto* host = [&]() -> Element* {
 264     auto* sheet = GetStyleSheet();
 265     if (!sheet) {
 266       return nullptr;
 267     }
 268     if (auto* owner = sheet->GetAssociatedDocumentOrShadowRoot()) {
 269       if (auto* shadow = ShadowRoot::FromNode(owner->AsNode())) {
 270         return shadow->Host();
 271       }
 272     }
 273     for (auto* adopter : sheet->SelfOrAncestorAdopters()) {
 274       // Try to guess. This is not fully correct but it's the best we can do
 275       // with the info at hand...
 276       auto* shadow = ShadowRoot::FromNode(adopter->AsNode());
 277       if (!shadow) {
 278         continue;
 279       }
 280       if (shadow->Host() == &aElement ||
 281           shadow == aElement.GetContainingShadow()) {
 282         return shadow->Host();
 283       }
 284     }
 285     return nullptr;
 286   }();
 287
 288   AutoTArray<const StyleLockedStyleRule*, 8> rules;
 289   CollectStyleRules(*this, /* aDesugared = */ true, rules);
 290
 291   return Servo_StyleRule_SelectorMatchesElement(
 292       &rules, &aElement, aSelectorIndex, host, *pseudoType,
 293       aRelevantLinkVisited);
 294 }
 295
 296 SelectorWarningKind ToWebIDLSelectorWarningKind(
 297     StyleSelectorWarningKind aKind) {
 298   switch (aKind) {
 299     case StyleSelectorWarningKind::UnconstraintedRelativeSelector:
 300       return SelectorWarningKind::UnconstrainedHas;
 301   }
 302   MOZ_ASSERT_UNREACHABLE("Unhandled selector warning kind");
 303   // Return something for assert-disabled builds.
 304   return SelectorWarningKind::UnconstrainedHas;
 305 }
 306
 307 void CSSStyleRule::GetSelectorWarnings(
 308     nsTArray<SelectorWarning>& aResult) const {
 309   nsTArray<StyleSelectorWarningData> result;
 310   Servo_GetSelectorWarnings(mRawRule, &result);
 311   for (const auto& warning : result) {
 312     auto& entry = *aResult.AppendElement();
 313     entry.mIndex = warning.index;
 314     entry.mKind = ToWebIDLSelectorWarningKind(warning.kind);
 315   }
 316 }
 317
 318 already_AddRefed<nsINodeList> CSSStyleRule::QuerySelectorAll(nsINode& aRoot) {
 319   AutoTArray<const StyleLockedStyleRule*, 8> rules;
 320   CollectStyleRules(*this, /* aDesugared = */ true, rules);
 321   StyleSelectorList* list = Servo_StyleRule_GetSelectorList(&rules);
 322
 323   auto contentList = MakeRefPtr<nsSimpleContentList>(&aRoot);
 324   Servo_SelectorList_QueryAll(&aRoot, list, contentList.get(),
 325                               /* useInvalidation */ false);
 326   Servo_SelectorList_Drop(list);
 327   return contentList.forget();
 328 }
 329
 330 /* virtual */
 331 JSObject* CSSStyleRule::WrapObject(JSContext* aCx,
 332                                    JS::Handle<JSObject*> aGivenProto) {
 333   return CSSStyleRule_Binding::Wrap(aCx, this, aGivenProto);
 334 }
 335
 336 }  // namespace mozilla::dom