Add m-esr52 at 52.6.0

1 files changed, 673 insertions, 0 deletions

diff --git a/layout/style/nsCSSRules.h b/layout/style/nsCSSRules.h
new file mode 100644
index 000000000..daefaf3f9
--- /dev/null
+++ b/layout/style/nsCSSRules.h
@@ -0,0 +1,673 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
+/* 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/. */
+
+/* rules in a CSS stylesheet other than style rules (e.g., @import rules) */
+
+#ifndef nsCSSRules_h_
+#define nsCSSRules_h_
+
+#include "Declaration.h"
+#include "StyleRule.h"
+#include "gfxFontFeatures.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Move.h"
+#include "mozilla/SheetType.h"
+#include "mozilla/css/GroupRule.h"
+#include "mozilla/dom/FontFace.h"
+#include "nsAutoPtr.h"
+#include "nsCSSPropertyID.h"
+#include "nsCSSValue.h"
+#include "nsDOMCSSDeclaration.h"
+#include "nsIDOMCSSConditionRule.h"
+#include "nsIDOMCSSCounterStyleRule.h"
+#include "nsIDOMCSSFontFaceRule.h"
+#include "nsIDOMCSSFontFeatureValuesRule.h"
+#include "nsIDOMCSSGroupingRule.h"
+#include "nsIDOMCSSMediaRule.h"
+#include "nsIDOMCSSMozDocumentRule.h"
+#include "nsIDOMCSSPageRule.h"
+#include "nsIDOMCSSSupportsRule.h"
+#include "nsIDOMCSSKeyframeRule.h"
+#include "nsIDOMCSSKeyframesRule.h"
+#include "nsTArray.h"
+
+class nsMediaList;
+
+namespace mozilla {
+
+class ErrorResult;
+
+namespace css {
+
+class MediaRule final : public GroupRule,
+                        public nsIDOMCSSMediaRule
+{
+public:
+  MediaRule(uint32_t aLineNumber, uint32_t aColumnNumber);
+private:
+  MediaRule(const MediaRule& aCopy);
+  ~MediaRule();
+public:
+
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MediaRule, GroupRule)
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // Rule methods
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual void SetStyleSheet(mozilla::CSSStyleSheet* aSheet) override; //override GroupRule
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<Rule> Clone() const override;
+  virtual nsIDOMCSSRule* GetDOMRule() override
+  {
+    return this;
+  }
+  virtual nsIDOMCSSRule* GetExistingDOMRule() override
+  {
+    return this;
+  }
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSGroupingRule interface
+  NS_DECL_NSIDOMCSSGROUPINGRULE
+
+  // nsIDOMCSSConditionRule interface
+  NS_DECL_NSIDOMCSSCONDITIONRULE
+
+  // nsIDOMCSSMediaRule interface
+  NS_DECL_NSIDOMCSSMEDIARULE
+
+  // rest of GroupRule
+  virtual bool UseForPresentation(nsPresContext* aPresContext,
+                                    nsMediaQueryResultCacheKey& aKey) override;
+
+  // @media rule methods
+  nsresult SetMedia(nsMediaList* aMedia);
+  
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
+    const override MOZ_MUST_OVERRIDE;
+
+protected:
+  void AppendConditionText(nsAString& aOutput);
+
+  RefPtr<nsMediaList> mMedia;
+};
+
+class DocumentRule final : public GroupRule,
+                           public nsIDOMCSSMozDocumentRule
+{
+public:
+  DocumentRule(uint32_t aLineNumber, uint32_t aColumnNumber);
+private:
+  DocumentRule(const DocumentRule& aCopy);
+  ~DocumentRule();
+public:
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // Rule methods
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<Rule> Clone() const override;
+  virtual nsIDOMCSSRule* GetDOMRule() override
+  {
+    return this;
+  }
+  virtual nsIDOMCSSRule* GetExistingDOMRule() override
+  {
+    return this;
+  }
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSGroupingRule interface
+  NS_DECL_NSIDOMCSSGROUPINGRULE
+
+  // nsIDOMCSSConditionRule interface
+  NS_DECL_NSIDOMCSSCONDITIONRULE
+
+  // nsIDOMCSSMozDocumentRule interface
+  NS_DECL_NSIDOMCSSMOZDOCUMENTRULE
+
+  // rest of GroupRule
+  virtual bool UseForPresentation(nsPresContext* aPresContext,
+                                    nsMediaQueryResultCacheKey& aKey) override;
+
+  bool UseForPresentation(nsPresContext* aPresContext);
+
+  enum Function {
+    eURL,
+    eURLPrefix,
+    eDomain,
+    eRegExp
+  };
+
+  struct URL {
+    Function func;
+    nsCString url;
+    URL *next;
+
+    URL() : next(nullptr) {}
+    URL(const URL& aOther)
+      : func(aOther.func)
+      , url(aOther.url)
+      , next(aOther.next ? new URL(*aOther.next) : nullptr)
+    {
+    }
+    ~URL();
+  };
+
+  void SetURLs(URL *aURLs) { mURLs = aURLs; }
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
+    const override MOZ_MUST_OVERRIDE;
+
+protected:
+  void AppendConditionText(nsAString& aOutput);
+
+  nsAutoPtr<URL> mURLs; // linked list of |struct URL| above.
+};
+
+} // namespace css
+
+struct CSSFontFaceDescriptors
+{
+#define CSS_FONT_DESC(name_, method_) nsCSSValue m##method_;
+#include "nsCSSFontDescList.h"
+#undef CSS_FONT_DESC
+
+  const nsCSSValue& Get(nsCSSFontDesc aFontDescID) const;
+  nsCSSValue& Get(nsCSSFontDesc aFontDescID);
+
+private:
+  static nsCSSValue CSSFontFaceDescriptors::* const Fields[];
+};
+
+} // namespace mozilla
+
+// A nsCSSFontFaceStyleDecl is always embedded in a nsCSSFontFaceRule.
+class nsCSSFontFaceRule;
+class nsCSSFontFaceStyleDecl final : public nsICSSDeclaration
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER
+  NS_DECL_NSICSSDECLARATION
+  virtual already_AddRefed<mozilla::dom::CSSValue>
+  GetPropertyCSSValue(const nsAString& aProp, mozilla::ErrorResult& aRv)
+    override;
+  using nsICSSDeclaration::GetPropertyCSSValue;
+
+  virtual nsINode *GetParentObject() override;
+  virtual void IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aPropName) override;
+
+  nsresult GetPropertyValue(nsCSSFontDesc aFontDescID,
+                            nsAString & aResult) const;
+
+  virtual JSObject* WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
+
+protected:
+  ~nsCSSFontFaceStyleDecl() {}
+
+  friend class nsCSSFontFaceRule;
+
+  inline nsCSSFontFaceRule* ContainingRule();
+  inline const nsCSSFontFaceRule* ContainingRule() const;
+
+  mozilla::CSSFontFaceDescriptors mDescriptors;
+
+private:
+  // NOT TO BE IMPLEMENTED
+  // This object cannot be allocated on its own, only as part of
+  // nsCSSFontFaceRule.
+  void* operator new(size_t size) CPP_THROW_NEW;
+};
+
+class nsCSSFontFaceRule final : public mozilla::css::Rule,
+                                public nsIDOMCSSFontFaceRule
+{
+public:
+  nsCSSFontFaceRule(uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::Rule(aLineNumber, aColumnNumber) {}
+
+  nsCSSFontFaceRule(const nsCSSFontFaceRule& aCopy)
+    // copy everything except our reference count
+    : mozilla::css::Rule(aCopy), mDecl(aCopy.mDecl) {}
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSFontFaceRule,
+                                                         mozilla::css::Rule)
+
+  // Rule methods
+  DECL_STYLE_RULE_INHERIT
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSFontFaceRule interface
+  NS_DECL_NSIDOMCSSFONTFACERULE
+
+  void SetDesc(nsCSSFontDesc aDescID, nsCSSValue const & aValue);
+  void GetDesc(nsCSSFontDesc aDescID, nsCSSValue & aValue);
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+  void GetDescriptors(mozilla::CSSFontFaceDescriptors& aDescriptors) const
+    { aDescriptors = mDecl.mDescriptors; }
+
+protected:
+  ~nsCSSFontFaceRule() {}
+
+  friend class nsCSSFontFaceStyleDecl;
+  nsCSSFontFaceStyleDecl mDecl;
+};
+
+// nsFontFaceRuleContainer - used for associating sheet type with
+// specific @font-face rules
+struct nsFontFaceRuleContainer {
+  RefPtr<nsCSSFontFaceRule> mRule;
+  mozilla::SheetType mSheetType;
+};
+
+inline nsCSSFontFaceRule*
+nsCSSFontFaceStyleDecl::ContainingRule()
+{
+  return reinterpret_cast<nsCSSFontFaceRule*>
+    (reinterpret_cast<char*>(this) - offsetof(nsCSSFontFaceRule, mDecl));
+}
+
+inline const nsCSSFontFaceRule*
+nsCSSFontFaceStyleDecl::ContainingRule() const
+{
+  return reinterpret_cast<const nsCSSFontFaceRule*>
+    (reinterpret_cast<const char*>(this) - offsetof(nsCSSFontFaceRule, mDecl));
+}
+
+class nsCSSFontFeatureValuesRule final : public mozilla::css::Rule,
+                                         public nsIDOMCSSFontFeatureValuesRule
+{
+public:
+  nsCSSFontFeatureValuesRule(uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::Rule(aLineNumber, aColumnNumber) {}
+
+  nsCSSFontFeatureValuesRule(const nsCSSFontFeatureValuesRule& aCopy)
+    // copy everything except our reference count
+    : mozilla::css::Rule(aCopy),
+      mFamilyList(aCopy.mFamilyList),
+      mFeatureValues(aCopy.mFeatureValues) {}
+
+  NS_DECL_ISUPPORTS
+
+  // Rule methods
+  DECL_STYLE_RULE_INHERIT
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSFontFaceRule interface
+  NS_DECL_NSIDOMCSSFONTFEATUREVALUESRULE
+
+  const mozilla::FontFamilyList& GetFamilyList() { return mFamilyList; }
+  void SetFamilyList(const mozilla::FontFamilyList& aFamilyList);
+
+  void AddValueList(int32_t aVariantAlternate,
+                    nsTArray<gfxFontFeatureValueSet::ValueList>& aValueList);
+
+  const nsTArray<gfxFontFeatureValueSet::FeatureValues>& GetFeatureValues()
+  {
+    return mFeatureValues;
+  }
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+protected:
+  ~nsCSSFontFeatureValuesRule() {}
+
+  mozilla::FontFamilyList mFamilyList;
+  nsTArray<gfxFontFeatureValueSet::FeatureValues> mFeatureValues;
+};
+
+class nsCSSKeyframeRule;
+
+class nsCSSKeyframeStyleDeclaration final : public nsDOMCSSDeclaration
+{
+public:
+  explicit nsCSSKeyframeStyleDeclaration(nsCSSKeyframeRule *aRule);
+
+  NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) override;
+  void DropReference() { mRule = nullptr; }
+  virtual mozilla::DeclarationBlock* GetCSSDeclaration(Operation aOperation) override;
+  virtual nsresult SetCSSDeclaration(mozilla::DeclarationBlock* aDecl) override;
+  virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) override;
+  virtual nsIDocument* DocToUpdate() override;
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSKeyframeStyleDeclaration,
+                                                         nsICSSDeclaration)
+
+  virtual nsINode* GetParentObject() override;
+
+protected:
+  virtual ~nsCSSKeyframeStyleDeclaration();
+
+  // This reference is not reference-counted. The rule object tells us
+  // when it's about to go away.
+  nsCSSKeyframeRule* MOZ_NON_OWNING_REF mRule;
+};
+
+class nsCSSKeyframeRule final : public mozilla::css::Rule,
+                                public nsIDOMCSSKeyframeRule
+{
+public:
+  // Steals the contents of aKeys, and takes the reference in Declaration
+  nsCSSKeyframeRule(InfallibleTArray<float>&& aKeys,
+                    already_AddRefed<mozilla::css::Declaration>&& aDeclaration,
+                    uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::Rule(aLineNumber, aColumnNumber)
+    , mKeys(mozilla::Move(aKeys))
+    , mDeclaration(mozilla::Move(aDeclaration))
+  {
+    mDeclaration->SetOwningRule(this);
+  }
+private:
+  nsCSSKeyframeRule(const nsCSSKeyframeRule& aCopy);
+  ~nsCSSKeyframeRule();
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSKeyframeRule, mozilla::css::Rule)
+
+  // Rule methods
+  DECL_STYLE_RULE_INHERIT
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSKeyframeRule interface
+  NS_DECL_NSIDOMCSSKEYFRAMERULE
+
+  const nsTArray<float>& GetKeys() const     { return mKeys; }
+  mozilla::css::Declaration* Declaration()   { return mDeclaration; }
+
+  void ChangeDeclaration(mozilla::css::Declaration* aDeclaration);
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+  void DoGetKeyText(nsAString &aKeyText) const;
+
+private:
+  nsTArray<float>                            mKeys;
+  RefPtr<mozilla::css::Declaration>          mDeclaration;
+  // lazily created when needed:
+  RefPtr<nsCSSKeyframeStyleDeclaration>    mDOMDeclaration;
+};
+
+class nsCSSKeyframesRule final : public mozilla::css::GroupRule,
+                                 public nsIDOMCSSKeyframesRule
+{
+public:
+  nsCSSKeyframesRule(const nsSubstring& aName,
+                     uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::GroupRule(aLineNumber, aColumnNumber)
+    , mName(aName)
+  {
+  }
+private:
+  nsCSSKeyframesRule(const nsCSSKeyframesRule& aCopy);
+  ~nsCSSKeyframesRule();
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // Rule methods
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+  virtual nsIDOMCSSRule* GetDOMRule() override
+  {
+    return this;
+  }
+  virtual nsIDOMCSSRule* GetExistingDOMRule() override
+  {
+    return this;
+  }
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSKeyframesRule interface
+  NS_DECL_NSIDOMCSSKEYFRAMESRULE
+
+  // rest of GroupRule
+  virtual bool UseForPresentation(nsPresContext* aPresContext,
+                                    nsMediaQueryResultCacheKey& aKey) override;
+
+  const nsString& GetName() { return mName; }
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+private:
+  uint32_t FindRuleIndexForKey(const nsAString& aKey);
+
+  nsString                                   mName;
+};
+
+class nsCSSPageRule;
+
+class nsCSSPageStyleDeclaration final : public nsDOMCSSDeclaration
+{
+public:
+  explicit nsCSSPageStyleDeclaration(nsCSSPageRule *aRule);
+
+  NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) override;
+  void DropReference() { mRule = nullptr; }
+  virtual mozilla::DeclarationBlock* GetCSSDeclaration(Operation aOperation) override;
+  virtual nsresult SetCSSDeclaration(mozilla::DeclarationBlock* aDecl) override;
+  virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) override;
+  virtual nsIDocument* DocToUpdate() override;
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSPageStyleDeclaration,
+                                                         nsICSSDeclaration)
+
+  virtual nsINode *GetParentObject() override;
+
+protected:
+  virtual ~nsCSSPageStyleDeclaration();
+
+  // This reference is not reference-counted. The rule object tells us
+  // when it's about to go away.
+  nsCSSPageRule* MOZ_NON_OWNING_REF mRule;
+};
+
+class nsCSSPageRule final : public mozilla::css::Rule,
+                            public nsIDOMCSSPageRule
+{
+public:
+  nsCSSPageRule(mozilla::css::Declaration* aDeclaration,
+                uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::Rule(aLineNumber, aColumnNumber)
+    , mDeclaration(aDeclaration)
+  {
+    mDeclaration->SetOwningRule(this);
+  }
+private:
+  nsCSSPageRule(const nsCSSPageRule& aCopy);
+  ~nsCSSPageRule();
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSPageRule, nsIDOMCSSPageRule)
+
+  // Rule methods
+  DECL_STYLE_RULE_INHERIT
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSPageRule interface
+  NS_DECL_NSIDOMCSSPAGERULE
+
+  mozilla::css::Declaration* Declaration()   { return mDeclaration; }
+
+  void ChangeDeclaration(mozilla::css::Declaration* aDeclaration);
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+private:
+  RefPtr<mozilla::css::Declaration>     mDeclaration;
+  // lazily created when needed:
+  RefPtr<nsCSSPageStyleDeclaration>     mDOMDeclaration;
+};
+
+namespace mozilla {
+
+class CSSSupportsRule : public css::GroupRule,
+                        public nsIDOMCSSSupportsRule
+{
+public:
+  CSSSupportsRule(bool aConditionMet, const nsString& aCondition,
+                  uint32_t aLineNumber, uint32_t aColumnNumber);
+  CSSSupportsRule(const CSSSupportsRule& aCopy);
+
+  // Rule methods
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+  virtual bool UseForPresentation(nsPresContext* aPresContext,
+                                  nsMediaQueryResultCacheKey& aKey) override;
+  virtual nsIDOMCSSRule* GetDOMRule() override
+  {
+    return this;
+  }
+  virtual nsIDOMCSSRule* GetExistingDOMRule() override
+  {
+    return this;
+  }
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSGroupingRule interface
+  NS_DECL_NSIDOMCSSGROUPINGRULE
+
+  // nsIDOMCSSConditionRule interface
+  NS_DECL_NSIDOMCSSCONDITIONRULE
+
+  // nsIDOMCSSSupportsRule interface
+  NS_DECL_NSIDOMCSSSUPPORTSRULE
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+protected:
+  virtual ~CSSSupportsRule();
+
+  bool mUseGroup;
+  nsString mCondition;
+};
+
+} // namespace mozilla
+
+class nsCSSCounterStyleRule final : public mozilla::css::Rule,
+                                    public nsIDOMCSSCounterStyleRule
+{
+public:
+  explicit nsCSSCounterStyleRule(const nsAString& aName,
+                                 uint32_t aLineNumber, uint32_t aColumnNumber)
+    : mozilla::css::Rule(aLineNumber, aColumnNumber)
+    , mName(aName)
+    , mGeneration(0)
+  {
+  }
+
+private:
+  nsCSSCounterStyleRule(const nsCSSCounterStyleRule& aCopy);
+  ~nsCSSCounterStyleRule();
+
+public:
+  NS_DECL_ISUPPORTS
+
+  // Rule methods
+  DECL_STYLE_RULE_INHERIT
+#ifdef DEBUG
+  virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
+#endif
+  virtual int32_t GetType() const override;
+  virtual already_AddRefed<mozilla::css::Rule> Clone() const override;
+
+  // nsIDOMCSSRule interface
+  NS_DECL_NSIDOMCSSRULE
+
+  // nsIDOMCSSCounterStyleRule
+  NS_DECL_NSIDOMCSSCOUNTERSTYLERULE
+
+  // This function is only used to check whether a non-empty value, which has
+  // been accepted by parser, is valid for the given system and descriptor.
+  static bool CheckDescValue(int32_t aSystem,
+                             nsCSSCounterDesc aDescID,
+                             const nsCSSValue& aValue);
+
+  const nsString& GetName() const { return mName; }
+
+  uint32_t GetGeneration() const { return mGeneration; }
+
+  int32_t GetSystem() const;
+  const nsCSSValue& GetSystemArgument() const;
+
+  const nsCSSValue& GetDesc(nsCSSCounterDesc aDescID) const
+  {
+    MOZ_ASSERT(aDescID >= 0 && aDescID < eCSSCounterDesc_COUNT,
+               "descriptor ID out of range");
+    return mValues[aDescID];
+  }
+
+  void SetDesc(nsCSSCounterDesc aDescID, const nsCSSValue& aValue);
+
+  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;
+
+private:
+  typedef NS_STDCALL_FUNCPROTO(nsresult, Getter, nsCSSCounterStyleRule,
+                               GetSymbols, (nsAString&));
+  static const Getter kGetters[];
+
+  nsresult GetDescriptor(nsCSSCounterDesc aDescID, nsAString& aValue);
+  nsresult SetDescriptor(nsCSSCounterDesc aDescID, const nsAString& aValue);
+
+  nsString   mName;
+  nsCSSValue mValues[eCSSCounterDesc_COUNT];
+  uint32_t   mGeneration;
+};
+
+#endif /* !defined(nsCSSRules_h_) */