DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (8b6d1b8364bd)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
/* -*- 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/. */

/* base class for all rule types in a CSS style sheet */

#ifndef mozilla_css_Rule_h___
#define mozilla_css_Rule_h___

#include "mozilla/dom/CSSRuleBinding.h"
#include "mozilla/dom/DocumentOrShadowRoot.h"
#include "mozilla/StyleSheet.h"
#include "mozilla/MemoryReporting.h"
#include "nsISupports.h"
#include "nsWrapperCache.h"

struct nsRuleData;
template <class T>
struct already_AddRefed;
class nsHTMLCSSStyleSheet;

namespace mozilla {
namespace css {
class GroupRule;

class Rule : public nsISupports, public nsWrapperCache {
 protected:
  Rule(StyleSheet* aSheet, Rule* aParentRule, uint32_t aLineNumber,
       uint32_t aColumnNumber)
      : mSheet(aSheet),
        mParentRule(aParentRule),
        mLineNumber(aLineNumber),
        mColumnNumber(aColumnNumber) {
#ifdef DEBUG
    // Would be nice to check that this->Type() is KEYFRAME_RULE when
    // mParentRule->Tye() is KEYFRAMES_RULE, but we can't call
    // this->Type() here since it's virtual.
    if (mParentRule) {
      int16_t type = mParentRule->Type();
      MOZ_ASSERT(type == dom::CSSRule_Binding::MEDIA_RULE ||
                 type == dom::CSSRule_Binding::DOCUMENT_RULE ||
                 type == dom::CSSRule_Binding::SUPPORTS_RULE ||
                 type == dom::CSSRule_Binding::KEYFRAMES_RULE);
    }
#endif
  }

  Rule(const Rule& aCopy)
      : mSheet(aCopy.mSheet),
        mParentRule(aCopy.mParentRule),
        mLineNumber(aCopy.mLineNumber),
        mColumnNumber(aCopy.mColumnNumber) {}

  virtual ~Rule() = default;

 public:
  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS(Rule)
  // Return true if this rule is known to be a cycle collection leaf, in the
  // sense that it doesn't have any outgoing owning edges.
  virtual bool IsCCLeaf() const MOZ_MUST_OVERRIDE;

#ifdef DEBUG
  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const = 0;
#endif

  StyleSheet* GetStyleSheet() const { return mSheet; }

  // Return the document the rule applies to, if any.
  //
  // Suitable for style updates, and that's about it.
  dom::Document* GetComposedDoc() const {
    return mSheet ? mSheet->GetComposedDoc() : nullptr;
  }

  // Clear the mSheet pointer on this rule and descendants.
  virtual void DropSheetReference();

  // Clear the mParentRule pointer on this rule.
  void DropParentRuleReference() { mParentRule = nullptr; }

  void DropReferences() {
    DropSheetReference();
    DropParentRuleReference();
  }

  uint32_t GetLineNumber() const { return mLineNumber; }
  uint32_t GetColumnNumber() const { return mColumnNumber; }

  // Whether this a rule in a read only style sheet.
  bool IsReadOnly() const;

  // Whether this rule is an @import rule that hasn't loaded yet (and thus
  // doesn't affect the style of the page).
  bool IsIncompleteImportRule() const;

  // This is pure virtual because all of Rule's data members are non-owning and
  // thus measured elsewhere.
  virtual size_t SizeOfIncludingThis(MallocSizeOf) const MOZ_MUST_OVERRIDE = 0;

  // WebIDL interface
  virtual uint16_t Type() const = 0;
  virtual void GetCssText(nsAString& aCssText) const = 0;
  void SetCssText(const nsAString& aCssText);
  Rule* GetParentRule() const;
  StyleSheet* GetParentStyleSheet() const { return GetStyleSheet(); }
  nsINode* GetParentObject() const {
    if (!mSheet) {
      return nullptr;
    }
    auto* associated = mSheet->GetAssociatedDocumentOrShadowRoot();
    return associated ? &associated->AsNode() : nullptr;
  }

 protected:
  // True if we're known-live for cycle collection purposes.
  bool IsKnownLive() const;

  // Hook subclasses can use to properly unlink the nsWrapperCache of
  // their declarations.
  void UnlinkDeclarationWrapper(nsWrapperCache& aDecl);

  // mSheet should only ever be null when we create a synthetic CSSFontFaceRule
  // for an InspectorFontFace.
  //
  // mSheet and mParentRule will be cleared when they are detached from the
  // parent object, either because the rule is removed or the parent is
  // destroyed.
  StyleSheet* MOZ_NON_OWNING_REF mSheet;
  Rule* MOZ_NON_OWNING_REF mParentRule;

  // Keep the same type so that MSVC packs them.
  uint32_t mLineNumber;
  uint32_t mColumnNumber;
};

}  // namespace css
}  // namespace mozilla

#endif /* mozilla_css_Rule_h___ */