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
   9 #include "mozilla/CSSEnabledState.h"
  10 #include "mozilla/DeclarationBlock.h"
  11 #include "mozilla/PseudoStyleType.h"
  12 #include "mozilla/ServoBindings.h"
  13 #include "mozilla/dom/CSSStyleRuleBinding.h"
  14 #include "nsCSSPseudoElements.h"
  15
  16 #include "mozAutoDocUpdate.h"
  17 #include "nsISupports.h"
  18
  19 namespace mozilla::dom {
  20
  21 // -- CSSStyleRuleDeclaration ---------------------------------------
  22
  23 CSSStyleRuleDeclaration::CSSStyleRuleDeclaration(
  24     already_AddRefed<RawServoDeclarationBlock> 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 CSSStyleRule::SetRawAfterClone(RefPtr<RawServoStyleRule> aRaw) {
  70   mRawRule = std::move(aRaw);
  71   mDecls.SetRawAfterClone(Servo_StyleRule_GetStyle(mRawRule).Consume());
  72 }
  73
  74 void CSSStyleRuleDeclaration::SetRawAfterClone(
  75     RefPtr<RawServoDeclarationBlock> aRaw) {
  76   RefPtr<DeclarationBlock> block = new DeclarationBlock(aRaw.forget());
  77   mDecls->SetOwningRule(nullptr);
  78   mDecls = std::move(block);
  79   mDecls->SetOwningRule(Rule());
  80 }
  81
  82 nsresult CSSStyleRuleDeclaration::SetCSSDeclaration(
  83     DeclarationBlock* aDecl, MutationClosureData* aClosureData) {
  84   CSSStyleRule* rule = Rule();
  85
  86   if (StyleSheet* sheet = rule->GetStyleSheet()) {
  87     if (aDecl != mDecls) {
  88       mDecls->SetOwningRule(nullptr);
  89       RefPtr<DeclarationBlock> decls = aDecl;
  90       Servo_StyleRule_SetStyle(rule->Raw(), decls->Raw());
  91       mDecls = std::move(decls);
  92       mDecls->SetOwningRule(rule);
  93     }
  94     sheet->RuleChanged(rule, StyleRuleChangeKind::StyleRuleDeclarations);
  95   }
  96   return NS_OK;
  97 }
  98
  99 Document* CSSStyleRuleDeclaration::DocToUpdate() { return nullptr; }
 100
 101 nsDOMCSSDeclaration::ParsingEnvironment
 102 CSSStyleRuleDeclaration::GetParsingEnvironment(
 103     nsIPrincipal* aSubjectPrincipal) const {
 104   return GetParsingEnvironmentForRule(Rule(), StyleCssRuleType::Style);
 105 }
 106
 107 // -- CSSStyleRule --------------------------------------------------
 108
 109 CSSStyleRule::CSSStyleRule(already_AddRefed<RawServoStyleRule> aRawRule,
 110                            StyleSheet* aSheet, css::Rule* aParentRule,
 111                            uint32_t aLine, uint32_t aColumn)
 112     : BindingStyleRule(aSheet, aParentRule, aLine, aColumn),
 113       mRawRule(aRawRule),
 114       mDecls(Servo_StyleRule_GetStyle(mRawRule).Consume()) {}
 115
 116 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(CSSStyleRule, css::Rule)
 117
 118 NS_IMPL_CYCLE_COLLECTION_CLASS(CSSStyleRule)
 119
 120 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(CSSStyleRule, css::Rule)
 121   // Keep this in sync with IsCCLeaf.
 122
 123   // Trace the wrapper for our declaration.  This just expands out
 124   // NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER which we can't use
 125   // directly because the wrapper is on the declaration, not on us.
 126   tmp->mDecls.TraceWrapper(aCallbacks, aClosure);
 127 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 128
 129 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CSSStyleRule)
 130   // Keep this in sync with IsCCLeaf.
 131
 132   // Unlink the wrapper for our declaration.
 133   //
 134   // Note that this has to happen before unlinking css::Rule.
 135   tmp->UnlinkDeclarationWrapper(tmp->mDecls);
 136   NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR
 137 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(css::Rule)
 138
 139 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSStyleRule, css::Rule)
 140   // Keep this in sync with IsCCLeaf.
 141 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 142
 143 bool CSSStyleRule::IsCCLeaf() const {
 144   if (!Rule::IsCCLeaf()) {
 145     return false;
 146   }
 147
 148   return !mDecls.PreservingWrapper();
 149 }
 150
 151 size_t CSSStyleRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
 152   size_t n = aMallocSizeOf(this);
 153
 154   // Measurement of the following members may be added later if DMD finds it
 155   // is worthwhile:
 156   // - mRawRule
 157   // - mDecls
 158
 159   return n;
 160 }
 161
 162 #ifdef DEBUG
 163 void CSSStyleRule::List(FILE* out, int32_t aIndent) const {
 164   nsAutoCString str;
 165   for (int32_t i = 0; i < aIndent; i++) {
 166     str.AppendLiteral("  ");
 167   }
 168   Servo_StyleRule_Debug(mRawRule, &str);
 169   fprintf_stderr(out, "%s\n", str.get());
 170 }
 171 #endif
 172
 173 /* CSSRule implementation */
 174
 175 StyleCssRuleType CSSStyleRule::Type() const { return StyleCssRuleType::Style; }
 176
 177 void CSSStyleRule::GetCssText(nsACString& aCssText) const {
 178   Servo_StyleRule_GetCssText(mRawRule, &aCssText);
 179 }
 180
 181 nsICSSDeclaration* CSSStyleRule::Style() { return &mDecls; }
 182
 183 /* CSSStyleRule implementation */
 184
 185 void CSSStyleRule::GetSelectorText(nsACString& aSelectorText) {
 186   Servo_StyleRule_GetSelectorText(mRawRule, &aSelectorText);
 187 }
 188
 189 void CSSStyleRule::SetSelectorText(const nsACString& aSelectorText) {
 190   if (IsReadOnly()) {
 191     return;
 192   }
 193
 194   if (StyleSheet* sheet = GetStyleSheet()) {
 195     sheet->WillDirty();
 196
 197     // TODO(emilio): May actually be more efficient to handle this as rule
 198     // removal + addition, from the point of view of invalidation...
 199     const RawServoStyleSheetContents* contents = sheet->RawContents();
 200     if (Servo_StyleRule_SetSelectorText(contents, mRawRule, &aSelectorText)) {
 201       sheet->RuleChanged(this, StyleRuleChangeKind::Generic);
 202     }
 203   }
 204 }
 205
 206 uint32_t CSSStyleRule::GetSelectorCount() {
 207   uint32_t aCount;
 208   Servo_StyleRule_GetSelectorCount(mRawRule, &aCount);
 209   return aCount;
 210 }
 211
 212 nsresult CSSStyleRule::GetSelectorText(uint32_t aSelectorIndex,
 213                                        nsACString& aText) {
 214   Servo_StyleRule_GetSelectorTextAtIndex(mRawRule, aSelectorIndex, &aText);
 215   return NS_OK;
 216 }
 217
 218 nsresult CSSStyleRule::GetSpecificity(uint32_t aSelectorIndex,
 219                                       uint64_t* aSpecificity) {
 220   Servo_StyleRule_GetSpecificityAtIndex(mRawRule, aSelectorIndex, aSpecificity);
 221   return NS_OK;
 222 }
 223
 224 nsresult CSSStyleRule::SelectorMatchesElement(Element* aElement,
 225                                               uint32_t aSelectorIndex,
 226                                               const nsAString& aPseudo,
 227                                               bool aRelevantLinkVisited,
 228                                               bool* aMatches) {
 229   Maybe<PseudoStyleType> pseudoType = nsCSSPseudoElements::GetPseudoType(
 230       aPseudo, CSSEnabledState::IgnoreEnabledState);
 231   if (!pseudoType) {
 232     *aMatches = false;
 233     return NS_OK;
 234   }
 235
 236   *aMatches = Servo_StyleRule_SelectorMatchesElement(
 237       mRawRule, aElement, aSelectorIndex, *pseudoType, aRelevantLinkVisited);
 238   return NS_OK;
 239 }
 240
 241 NotNull<DeclarationBlock*> CSSStyleRule::GetDeclarationBlock() const {
 242   return WrapNotNull(mDecls.mDecls);
 243 }
 244
 245 }  // namespace mozilla::dom