layout/style/CSSPageRule.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/CSSPageRule.h"
   8 #include "mozilla/dom/CSSPageRuleBinding.h"
   9
  10 #include "mozilla/DeclarationBlock.h"
  11 #include "mozilla/ServoBindings.h"
  12
  13 namespace mozilla::dom {
  14
  15 // -- CSSPageRuleDeclaration ---------------------------------------
  16
  17 CSSPageRuleDeclaration::CSSPageRuleDeclaration(
  18     already_AddRefed<StyleLockedDeclarationBlock> aDecls)
  19     : mDecls(new DeclarationBlock(std::move(aDecls))) {
  20   mDecls->SetOwningRule(Rule());
  21 }
  22
  23 CSSPageRuleDeclaration::~CSSPageRuleDeclaration() {
  24   mDecls->SetOwningRule(nullptr);
  25 }
  26
  27 // QueryInterface implementation for CSSPageRuleDeclaration
  28 NS_INTERFACE_MAP_BEGIN(CSSPageRuleDeclaration)
  29   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  30   // We forward the cycle collection interfaces to Rule(), which is
  31   // never null (in fact, we're part of that object!)
  32   if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) ||
  33       aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant))) {
  34     return Rule()->QueryInterface(aIID, aInstancePtr);
  35   }
  36 NS_INTERFACE_MAP_END_INHERITING(nsDOMCSSDeclaration)
  37
  38 NS_IMPL_ADDREF_USING_AGGREGATOR(CSSPageRuleDeclaration, Rule())
  39 NS_IMPL_RELEASE_USING_AGGREGATOR(CSSPageRuleDeclaration, Rule())
  40
  41 /* nsDOMCSSDeclaration implementation */
  42
  43 css::Rule* CSSPageRuleDeclaration::GetParentRule() { return Rule(); }
  44
  45 nsINode* CSSPageRuleDeclaration::GetAssociatedNode() const {
  46   return Rule()->GetAssociatedDocumentOrShadowRoot();
  47 }
  48
  49 nsISupports* CSSPageRuleDeclaration::GetParentObject() const {
  50   return Rule()->GetParentObject();
  51 }
  52
  53 DeclarationBlock* CSSPageRuleDeclaration::GetOrCreateCSSDeclaration(
  54     Operation aOperation, DeclarationBlock** aCreated) {
  55   if (aOperation != Operation::Read) {
  56     if (StyleSheet* sheet = Rule()->GetStyleSheet()) {
  57       sheet->WillDirty();
  58     }
  59   }
  60   return mDecls;
  61 }
  62
  63 void CSSPageRuleDeclaration::SetRawAfterClone(
  64     RefPtr<StyleLockedDeclarationBlock> aDeclarationBlock) {
  65   mDecls->SetOwningRule(nullptr);
  66   mDecls = new DeclarationBlock(aDeclarationBlock.forget());
  67   mDecls->SetOwningRule(Rule());
  68 }
  69
  70 nsresult CSSPageRuleDeclaration::SetCSSDeclaration(
  71     DeclarationBlock* aDecl, MutationClosureData* aClosureData) {
  72   MOZ_ASSERT(aDecl, "must be non-null");
  73   CSSPageRule* rule = Rule();
  74
  75   if (aDecl != mDecls) {
  76     mDecls->SetOwningRule(nullptr);
  77     RefPtr<DeclarationBlock> decls = aDecl;
  78     Servo_PageRule_SetStyle(rule->Raw(), decls->Raw());
  79     mDecls = std::move(decls);
  80     mDecls->SetOwningRule(rule);
  81   }
  82
  83   return NS_OK;
  84 }
  85
  86 nsDOMCSSDeclaration::ParsingEnvironment
  87 CSSPageRuleDeclaration::GetParsingEnvironment(
  88     nsIPrincipal* aSubjectPrincipal) const {
  89   return GetParsingEnvironmentForRule(Rule(), StyleCssRuleType::Page);
  90 }
  91
  92 // -- CSSPageRule --------------------------------------------------
  93
  94 CSSPageRule::CSSPageRule(RefPtr<StyleLockedPageRule> aRawRule,
  95                          StyleSheet* aSheet, css::Rule* aParentRule,
  96                          uint32_t aLine, uint32_t aColumn)
  97     : css::Rule(aSheet, aParentRule, aLine, aColumn),
  98       mRawRule(std::move(aRawRule)),
  99       mDecls(Servo_PageRule_GetStyle(mRawRule).Consume()) {}
 100
 101 NS_IMPL_ADDREF_INHERITED(CSSPageRule, css::Rule)
 102 NS_IMPL_RELEASE_INHERITED(CSSPageRule, css::Rule)
 103
 104 // QueryInterface implementation for PageRule
 105 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CSSPageRule)
 106 NS_INTERFACE_MAP_END_INHERITING(css::Rule)
 107
 108 NS_IMPL_CYCLE_COLLECTION_CLASS(CSSPageRule)
 109
 110 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(CSSPageRule, css::Rule)
 111   // Keep this in sync with IsCCLeaf.
 112
 113   // Trace the wrapper for our declaration.  This just expands out
 114   // NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER which we can't use
 115   // directly because the wrapper is on the declaration, not on us.
 116   tmp->mDecls.TraceWrapper(aCallbacks, aClosure);
 117 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 118
 119 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(CSSPageRule)
 120   // Keep this in sync with IsCCLeaf.
 121
 122   // Unlink the wrapper for our declaration.
 123   //
 124   // Note that this has to happen before unlinking css::Rule.
 125   tmp->UnlinkDeclarationWrapper(tmp->mDecls);
 126   tmp->mDecls.mDecls->SetOwningRule(nullptr);
 127 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED(css::Rule)
 128
 129 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSPageRule, css::Rule)
 130   // Keep this in sync with IsCCLeaf.
 131 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 132
 133 bool CSSPageRule::IsCCLeaf() const {
 134   if (!Rule::IsCCLeaf()) {
 135     return false;
 136   }
 137
 138   return !mDecls.PreservingWrapper();
 139 }
 140
 141 void CSSPageRule::SetRawAfterClone(RefPtr<StyleLockedPageRule> aRaw) {
 142   mRawRule = std::move(aRaw);
 143   mDecls.SetRawAfterClone(Servo_PageRule_GetStyle(mRawRule.get()).Consume());
 144 }
 145
 146 StyleCssRuleType CSSPageRule::Type() const { return StyleCssRuleType::Page; }
 147
 148 size_t CSSPageRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
 149   // TODO Implement this!
 150   return aMallocSizeOf(this);
 151 }
 152
 153 #ifdef DEBUG
 154 void CSSPageRule::List(FILE* out, int32_t aIndent) const {
 155   nsAutoCString str;
 156   for (int32_t i = 0; i < aIndent; i++) {
 157     str.AppendLiteral("  ");
 158   }
 159   Servo_PageRule_Debug(mRawRule, &str);
 160   fprintf_stderr(out, "%s\n", str.get());
 161 }
 162 #endif
 163
 164 /* CSSRule implementation */
 165
 166 void CSSPageRule::GetCssText(nsACString& aCssText) const {
 167   Servo_PageRule_GetCssText(mRawRule, &aCssText);
 168 }
 169
 170 /* CSSPageRule implementation */
 171
 172 void CSSPageRule::GetSelectorText(nsACString& aSelectorText) const {
 173   Servo_PageRule_GetSelectorText(mRawRule.get(), &aSelectorText);
 174 }
 175
 176 void CSSPageRule::SetSelectorText(const nsACString& aSelectorText) {
 177   if (IsReadOnly()) {
 178     return;
 179   }
 180
 181   if (StyleSheet* const sheet = GetStyleSheet()) {
 182     sheet->WillDirty();
 183     const StyleStylesheetContents* const contents = sheet->RawContents();
 184     if (Servo_PageRule_SetSelectorText(contents, mRawRule.get(),
 185                                        &aSelectorText)) {
 186       sheet->RuleChanged(this, StyleRuleChangeKind::Generic);
 187     }
 188   }
 189 }
 190
 191 nsICSSDeclaration* CSSPageRule::Style() { return &mDecls; }
 192
 193 JSObject* CSSPageRule::WrapObject(JSContext* aCx,
 194                                   JS::Handle<JSObject*> aGivenProto) {
 195   return CSSPageRule_Binding::Wrap(aCx, this, aGivenProto);
 196 }
 197
 198 }  // namespace mozilla::dom