CSSStyleRule.cpp

/* -*- 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/. */

#include "mozilla/dom/CSSStyleRule.h"

#include "mozilla/DeclarationBlock.h"
#include "mozilla/ServoBindings.h"
#include "mozilla/dom/CSSStyleRuleBinding.h"

#include "mozAutoDocUpdate.h"

using namespace mozilla::dom;

namespace mozilla {
namespace dom {

// -- CSSStyleRuleDeclaration ---------------------------------------

CSSStyleRuleDeclaration::CSSStyleRuleDeclaration(
    already_AddRefed<RawServoDeclarationBlock> aDecls)
    : mDecls(new DeclarationBlock(std::move(aDecls))) {}

CSSStyleRuleDeclaration::~CSSStyleRuleDeclaration() {
  mDecls->SetOwningRule(nullptr);
}

// QueryInterface implementation for CSSStyleRuleDeclaration
NS_INTERFACE_MAP_BEGIN(CSSStyleRuleDeclaration)
  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  // We forward the cycle collection interfaces to Rule(), which is
  // never null (in fact, we're part of that object!)
  if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) ||
      aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant))) {
    return Rule()->QueryInterface(aIID, aInstancePtr);
  } else
    NS_IMPL_QUERY_TAIL_INHERITING(nsDOMCSSDeclaration)

  NS_IMPL_ADDREF_USING_AGGREGATOR(CSSStyleRuleDeclaration, Rule())
  NS_IMPL_RELEASE_USING_AGGREGATOR(CSSStyleRuleDeclaration, Rule())

  /* nsDOMCSSDeclaration implementation */

  css::Rule* CSSStyleRuleDeclaration::GetParentRule() { return Rule(); }

  nsINode* CSSStyleRuleDeclaration::GetParentObject() {
    return Rule()->GetParentObject();
  }

  DeclarationBlock* CSSStyleRuleDeclaration::GetOrCreateCSSDeclaration(
      Operation aOperation, DeclarationBlock * *aCreated) {
    return mDecls;
  }

  nsresult CSSStyleRuleDeclaration::SetCSSDeclaration(
      DeclarationBlock * aDecl, MutationClosureData * aClosureData) {
    CSSStyleRule* rule = Rule();
    if (RefPtr<StyleSheet> sheet = rule->GetStyleSheet()) {
      if (aDecl != mDecls) {
        mDecls->SetOwningRule(nullptr);
        RefPtr<DeclarationBlock> decls = aDecl;
        Servo_StyleRule_SetStyle(rule->Raw(), decls->Raw());
        mDecls = decls.forget();
        mDecls->SetOwningRule(rule);
      }
      sheet->RuleChanged(rule);
    }
    return NS_OK;
  }

  nsIDocument* CSSStyleRuleDeclaration::DocToUpdate() { return nullptr; }

  nsDOMCSSDeclaration::ParsingEnvironment
  CSSStyleRuleDeclaration::GetParsingEnvironment(nsIPrincipal *
                                                 aSubjectPrincipal) const {
    return GetParsingEnvironmentForRule(Rule());
  }

  // -- CSSStyleRule --------------------------------------------------

  CSSStyleRule::CSSStyleRule(already_AddRefed<RawServoStyleRule> aRawRule,
                             StyleSheet * aSheet, css::Rule * aParentRule,
                             uint32_t aLine, uint32_t aColumn)
      : BindingStyleRule(aSheet, aParentRule, aLine, aColumn),
        mRawRule(aRawRule),
        mDecls(Servo_StyleRule_GetStyle(mRawRule).Consume()) {}

  NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(CSSStyleRule, css::Rule)

  NS_IMPL_CYCLE_COLLECTION_CLASS(CSSStyleRule)

  NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(CSSStyleRule, css::Rule)
    // Keep this in sync with IsCCLeaf.

    // Trace the wrapper for our declaration.  This just expands out
    // NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER which we can't use
    // directly because the wrapper is on the declaration, not on us.
    tmp->mDecls.TraceWrapper(aCallbacks, aClosure);
  NS_IMPL_CYCLE_COLLECTION_TRACE_END

  NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(CSSStyleRule, css::Rule)
    // Keep this in sync with IsCCLeaf.

    // Unlink the wrapper for our declaraton.  This just expands out
    // NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER which we can't use
    // directly because the wrapper is on the declaration, not on us.
    tmp->mDecls.ReleaseWrapper(static_cast<nsISupports*>(p));
  NS_IMPL_CYCLE_COLLECTION_UNLINK_END

  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(CSSStyleRule, css::Rule)
    // Keep this in sync with IsCCLeaf.
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END

  bool CSSStyleRule::IsCCLeaf() const {
    if (!Rule::IsCCLeaf()) {
      return false;
    }

    return !mDecls.PreservingWrapper();
  }

  size_t CSSStyleRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
    size_t n = aMallocSizeOf(this);

    // Measurement of the following members may be added later if DMD finds it
    // is worthwhile:
    // - mRawRule
    // - mDecls

    return n;
  }

#ifdef DEBUG
  void CSSStyleRule::List(FILE * out, int32_t aIndent) const {
    nsAutoCString str;
    for (int32_t i = 0; i < aIndent; i++) {
      str.AppendLiteral("  ");
    }
    Servo_StyleRule_Debug(mRawRule, &str);
    fprintf_stderr(out, "%s\n", str.get());
  }
#endif

  /* CSSRule implementation */

  void CSSStyleRule::GetCssText(nsAString & aCssText) const {
    Servo_StyleRule_GetCssText(mRawRule, &aCssText);
  }

  nsICSSDeclaration* CSSStyleRule::Style() { return &mDecls; }

  /* CSSStyleRule implementation */

  void CSSStyleRule::GetSelectorText(nsAString & aSelectorText) {
    Servo_StyleRule_GetSelectorText(mRawRule, &aSelectorText);
  }

  void CSSStyleRule::SetSelectorText(const nsAString& aSelectorText) {
    if (RefPtr<StyleSheet> sheet = GetStyleSheet()) {
      // StyleRule lives inside of the Inner, it is unsafe to call WillDirty
      // if sheet does not already have a unique Inner.
      sheet->AssertHasUniqueInner();
      sheet->WillDirty();

      const RawServoStyleSheetContents* contents = sheet->RawContents();
      if (Servo_StyleRule_SetSelectorText(contents, mRawRule, &aSelectorText)) {
        sheet->RuleChanged(this);
      }
    }
  }

  uint32_t CSSStyleRule::GetSelectorCount() {
    uint32_t aCount;
    Servo_StyleRule_GetSelectorCount(mRawRule, &aCount);
    return aCount;
  }

  nsresult CSSStyleRule::GetSelectorText(uint32_t aSelectorIndex,
                                         nsAString & aText) {
    Servo_StyleRule_GetSelectorTextAtIndex(mRawRule, aSelectorIndex, &aText);
    return NS_OK;
  }

  nsresult CSSStyleRule::GetSpecificity(uint32_t aSelectorIndex,
                                        uint64_t * aSpecificity) {
    Servo_StyleRule_GetSpecificityAtIndex(mRawRule, aSelectorIndex,
                                          aSpecificity);
    return NS_OK;
  }

  nsresult CSSStyleRule::SelectorMatchesElement(
      Element * aElement, uint32_t aSelectorIndex, const nsAString& aPseudo,
      bool* aMatches) {
    CSSPseudoElementType pseudoType = CSSPseudoElementType::NotPseudo;
    if (!aPseudo.IsEmpty()) {
      RefPtr<nsAtom> pseudoElt = NS_Atomize(aPseudo);
      pseudoType = nsCSSPseudoElements::GetPseudoType(
          pseudoElt, CSSEnabledState::eIgnoreEnabledState);

      if (pseudoType == CSSPseudoElementType::NotPseudo) {
        *aMatches = false;
        return NS_OK;
      }
    }

    *aMatches = Servo_StyleRule_SelectorMatchesElement(
        mRawRule, aElement, aSelectorIndex, pseudoType);

    return NS_OK;
  }

  NotNull<DeclarationBlock*> CSSStyleRule::GetDeclarationBlock() const {
    return WrapNotNull(mDecls.mDecls);
  }

}  // namespace dom
}  // namespace mozilla