The Tor Browser: layout/style/nsCSSRules.h@8bccb770b82d

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 // vim:cindent:ts=2:et:sw=2:

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

     7 /* rules in a CSS stylesheet other than style rules (e.g., @import rules) */

     9 #ifndef nsCSSRules_h_

    10 #define nsCSSRules_h_

    12 #include "mozilla/Attributes.h"

    14 #include "mozilla/MemoryReporting.h"

    15 #include "mozilla/css/GroupRule.h"

    16 #include "mozilla/Preferences.h"

    17 #include "nsIDOMCSSConditionRule.h"

    18 #include "nsIDOMCSSFontFaceRule.h"

    19 #include "nsIDOMCSSFontFeatureValuesRule.h"

    20 #include "nsIDOMCSSGroupingRule.h"

    21 #include "nsIDOMCSSMediaRule.h"

    22 #include "nsIDOMCSSMozDocumentRule.h"

    23 #include "nsIDOMCSSSupportsRule.h"

    24 #include "nsIDOMMozCSSKeyframeRule.h"

    25 #include "nsIDOMMozCSSKeyframesRule.h"

    26 #include "nsAutoPtr.h"

    27 #include "nsCSSProperty.h"

    28 #include "nsCSSValue.h"

    29 #include "nsIDOMCSSCharsetRule.h"

    30 #include "nsTArray.h"

    31 #include "nsDOMCSSDeclaration.h"

    32 #include "Declaration.h"

    33 #include "nsIDOMCSSPageRule.h"

    34 #include "StyleRule.h"

    35 #include "gfxFontFeatures.h"

    37 class nsMediaList;

    39 namespace mozilla {

    41 class ErrorResult;

    43 namespace css {

    45 class MediaRule MOZ_FINAL : public GroupRule,

    46                             public nsIDOMCSSMediaRule

    47 {

    48 public:

    49   MediaRule();

    50 private:

    51   MediaRule(const MediaRule& aCopy);

    52   ~MediaRule();

    53 public:

    55   NS_DECL_ISUPPORTS_INHERITED

    57   // nsIStyleRule methods

    58 #ifdef DEBUG

    59   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

    60 #endif

    62   // Rule methods

    63   virtual void SetStyleSheet(nsCSSStyleSheet* aSheet); //override GroupRule

    64   virtual int32_t GetType() const;

    65   virtual already_AddRefed<Rule> Clone() const;

    66   virtual nsIDOMCSSRule* GetDOMRule()

    67   {

    68     return this;

    69   }

    70   virtual nsIDOMCSSRule* GetExistingDOMRule()

    71   {

    72     return this;

    73   }

    75   // nsIDOMCSSRule interface

    76   NS_DECL_NSIDOMCSSRULE

    78   // nsIDOMCSSGroupingRule interface

    79   NS_DECL_NSIDOMCSSGROUPINGRULE

    81   // nsIDOMCSSConditionRule interface

    82   NS_DECL_NSIDOMCSSCONDITIONRULE

    84   // nsIDOMCSSMediaRule interface

    85   NS_DECL_NSIDOMCSSMEDIARULE

    87   // rest of GroupRule

    88   virtual bool UseForPresentation(nsPresContext* aPresContext,

    89                                     nsMediaQueryResultCacheKey& aKey);

    91   // @media rule methods

    92   nsresult SetMedia(nsMediaList* aMedia);

    94   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)

    95     const MOZ_MUST_OVERRIDE;

    97 protected:

    98   void AppendConditionText(nsAString& aOutput);

   100   nsRefPtr<nsMediaList> mMedia;

   101 };

   103 class DocumentRule MOZ_FINAL : public GroupRule,

   104                                public nsIDOMCSSMozDocumentRule

   105 {

   106 public:

   107   DocumentRule();

   108 private:

   109   DocumentRule(const DocumentRule& aCopy);

   110   ~DocumentRule();

   111 public:

   113   NS_DECL_ISUPPORTS_INHERITED

   115   // nsIStyleRule methods

   116 #ifdef DEBUG

   117   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   118 #endif

   120   // Rule methods

   121   virtual int32_t GetType() const;

   122   virtual already_AddRefed<Rule> Clone() const;

   123   virtual nsIDOMCSSRule* GetDOMRule()

   124   {

   125     return this;

   126   }

   127   virtual nsIDOMCSSRule* GetExistingDOMRule()

   128   {

   129     return this;

   130   }

   132   // nsIDOMCSSRule interface

   133   NS_DECL_NSIDOMCSSRULE

   135   // nsIDOMCSSGroupingRule interface

   136   NS_DECL_NSIDOMCSSGROUPINGRULE

   138   // nsIDOMCSSConditionRule interface

   139   NS_DECL_NSIDOMCSSCONDITIONRULE

   141   // nsIDOMCSSMozDocumentRule interface

   142   NS_DECL_NSIDOMCSSMOZDOCUMENTRULE

   144   // rest of GroupRule

   145   virtual bool UseForPresentation(nsPresContext* aPresContext,

   146                                     nsMediaQueryResultCacheKey& aKey);

   148   enum Function {

   149     eURL,

   150     eURLPrefix,

   151     eDomain,

   152     eRegExp

   153   };

   155   struct URL {

   156     Function func;

   157     nsCString url;

   158     URL *next;

   160     URL() : next(nullptr) {}

   161     URL(const URL& aOther)

   162       : func(aOther.func)

   163       , url(aOther.url)

   164       , next(aOther.next ? new URL(*aOther.next) : nullptr)

   165     {

   166     }

   167     ~URL();

   168   };

   170   void SetURLs(URL *aURLs) { mURLs = aURLs; }

   172   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)

   173     const MOZ_MUST_OVERRIDE;

   175 protected:

   176   void AppendConditionText(nsAString& aOutput);

   178   nsAutoPtr<URL> mURLs; // linked list of |struct URL| above.

   179 };

   181 } // namespace css

   182 } // namespace mozilla

   184 // A nsCSSFontFaceStyleDecl is always embedded in a nsCSSFontFaceRule.

   185 class nsCSSFontFaceRule;

   186 class nsCSSFontFaceStyleDecl : public nsICSSDeclaration

   187 {

   188 public:

   189   NS_DECL_ISUPPORTS_INHERITED

   190   NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER

   191   NS_DECL_NSICSSDECLARATION

   192   virtual already_AddRefed<mozilla::dom::CSSValue>

   193   GetPropertyCSSValue(const nsAString& aProp, mozilla::ErrorResult& aRv)

   194     MOZ_OVERRIDE;

   195   using nsICSSDeclaration::GetPropertyCSSValue;

   197   nsCSSFontFaceStyleDecl()

   198   {

   199     SetIsDOMBinding();

   200   }

   202   virtual nsINode *GetParentObject() MOZ_OVERRIDE;

   203   virtual void IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aPropName) MOZ_OVERRIDE;

   205   nsresult GetPropertyValue(nsCSSFontDesc aFontDescID,

   206                             nsAString & aResult) const;

   208   virtual JSObject* WrapObject(JSContext *cx) MOZ_OVERRIDE;

   210 protected:

   211   friend class nsCSSFontFaceRule;

   212 #define CSS_FONT_DESC(name_, method_) nsCSSValue m##method_;

   213 #include "nsCSSFontDescList.h"

   214 #undef CSS_FONT_DESC

   216   static nsCSSValue nsCSSFontFaceStyleDecl::* const Fields[];

   217   inline nsCSSFontFaceRule* ContainingRule();

   218   inline const nsCSSFontFaceRule* ContainingRule() const;

   220 private:

   221   // NOT TO BE IMPLEMENTED

   222   // This object cannot be allocated on its own, only as part of

   223   // nsCSSFontFaceRule.

   224   void* operator new(size_t size) CPP_THROW_NEW;

   225 };

   227 class nsCSSFontFaceRule MOZ_FINAL : public mozilla::css::Rule,

   228                                     public nsIDOMCSSFontFaceRule

   229 {

   230 public:

   231   nsCSSFontFaceRule() {}

   233   nsCSSFontFaceRule(const nsCSSFontFaceRule& aCopy)

   234     // copy everything except our reference count

   235     : mozilla::css::Rule(aCopy), mDecl(aCopy.mDecl) {}

   237   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

   238   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSFontFaceRule,

   239                                                          mozilla::css::Rule)

   241   // nsIStyleRule methods

   242 #ifdef DEBUG

   243   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   244 #endif

   246   // Rule methods

   247   DECL_STYLE_RULE_INHERIT

   249   virtual int32_t GetType() const MOZ_OVERRIDE;

   250   virtual already_AddRefed<mozilla::css::Rule> Clone() const;

   252   // nsIDOMCSSRule interface

   253   NS_DECL_NSIDOMCSSRULE

   255   // nsIDOMCSSFontFaceRule interface

   256   NS_DECL_NSIDOMCSSFONTFACERULE

   258   void SetDesc(nsCSSFontDesc aDescID, nsCSSValue const & aValue);

   259   void GetDesc(nsCSSFontDesc aDescID, nsCSSValue & aValue);

   261   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;

   263 protected:

   264   friend class nsCSSFontFaceStyleDecl;

   265   nsCSSFontFaceStyleDecl mDecl;

   266 };

   268 // nsFontFaceRuleContainer - used for associating sheet type with

   269 // specific @font-face rules

   270 struct nsFontFaceRuleContainer {

   271   nsRefPtr<nsCSSFontFaceRule> mRule;

   272   uint8_t mSheetType;

   273 };

   275 inline nsCSSFontFaceRule*

   276 nsCSSFontFaceStyleDecl::ContainingRule()

   277 {

   278   return reinterpret_cast<nsCSSFontFaceRule*>

   279     (reinterpret_cast<char*>(this) - offsetof(nsCSSFontFaceRule, mDecl));

   280 }

   282 inline const nsCSSFontFaceRule*

   283 nsCSSFontFaceStyleDecl::ContainingRule() const

   284 {

   285   return reinterpret_cast<const nsCSSFontFaceRule*>

   286     (reinterpret_cast<const char*>(this) - offsetof(nsCSSFontFaceRule, mDecl));

   287 }

   289 class nsCSSFontFeatureValuesRule MOZ_FINAL :

   290                                        public mozilla::css::Rule,

   291                                        public nsIDOMCSSFontFeatureValuesRule

   292 {

   293 public:

   294   nsCSSFontFeatureValuesRule() {}

   296   nsCSSFontFeatureValuesRule(const nsCSSFontFeatureValuesRule& aCopy)

   297     // copy everything except our reference count

   298     : mozilla::css::Rule(aCopy),

   299       mFamilyList(aCopy.mFamilyList),

   300       mFeatureValues(aCopy.mFeatureValues) {}

   302   NS_DECL_ISUPPORTS

   304   // nsIStyleRule methods

   305 #ifdef DEBUG

   306   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   307 #endif

   309   // Rule methods

   310   DECL_STYLE_RULE_INHERIT

   312   virtual int32_t GetType() const MOZ_OVERRIDE;

   313   virtual already_AddRefed<mozilla::css::Rule> Clone() const MOZ_OVERRIDE;

   315   // nsIDOMCSSRule interface

   316   NS_DECL_NSIDOMCSSRULE

   318   // nsIDOMCSSFontFaceRule interface

   319   NS_DECL_NSIDOMCSSFONTFEATUREVALUESRULE

   321   const nsTArray<nsString>& GetFamilyList() { return mFamilyList; }

   322   void SetFamilyList(const nsAString& aFamilyList, bool& aContainsGeneric);

   324   void AddValueList(int32_t aVariantAlternate,

   325                     nsTArray<gfxFontFeatureValueSet::ValueList>& aValueList);

   327   const nsTArray<gfxFontFeatureValueSet::FeatureValues>& GetFeatureValues()

   328   {

   329     return mFeatureValues;

   330   }

   332   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;

   334   static bool PrefEnabled()

   335   {

   336     // font-variant-alternates enabled ==> layout.css.font-features.enabled is true

   337     bool fontFeaturesEnabled =

   338       nsCSSProps::IsEnabled(eCSSProperty_font_variant_alternates);

   340     return fontFeaturesEnabled;

   341   }

   343 protected:

   344   nsTArray<nsString> mFamilyList;

   345   nsTArray<gfxFontFeatureValueSet::FeatureValues> mFeatureValues;

   346 };

   348 namespace mozilla {

   349 namespace css {

   351 class CharsetRule MOZ_FINAL : public Rule,

   352                               public nsIDOMCSSCharsetRule

   353 {

   354 public:

   355   CharsetRule(const nsAString& aEncoding);

   356 private:

   357   // For |Clone|

   358   CharsetRule(const CharsetRule& aCopy);

   359   ~CharsetRule() {}

   361 public:

   362   NS_DECL_ISUPPORTS

   364   DECL_STYLE_RULE_INHERIT

   366   // nsIStyleRule methods

   367 #ifdef DEBUG

   368   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   369 #endif

   371   // Rule methods

   372   virtual int32_t GetType() const;

   373   virtual already_AddRefed<Rule> Clone() const;

   375   // nsIDOMCSSRule interface

   376   NS_DECL_NSIDOMCSSRULE

   378   // nsIDOMCSSCharsetRule methods

   379   NS_IMETHOD GetEncoding(nsAString& aEncoding) MOZ_OVERRIDE;

   380   NS_IMETHOD SetEncoding(const nsAString& aEncoding) MOZ_OVERRIDE;

   382   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;

   384 private:

   385   nsString  mEncoding;

   386 };

   388 } // namespace css

   389 } // namespace mozilla

   391 class nsCSSKeyframeRule;

   393 class nsCSSKeyframeStyleDeclaration MOZ_FINAL : public nsDOMCSSDeclaration

   394 {

   395 public:

   396   nsCSSKeyframeStyleDeclaration(nsCSSKeyframeRule *aRule);

   397   virtual ~nsCSSKeyframeStyleDeclaration();

   399   NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) MOZ_OVERRIDE;

   400   void DropReference() { mRule = nullptr; }

   401   virtual mozilla::css::Declaration* GetCSSDeclaration(bool aAllocate) MOZ_OVERRIDE;

   402   virtual nsresult SetCSSDeclaration(mozilla::css::Declaration* aDecl) MOZ_OVERRIDE;

   403   virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) MOZ_OVERRIDE;

   404   virtual nsIDocument* DocToUpdate() MOZ_OVERRIDE;

   406   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

   407   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSKeyframeStyleDeclaration,

   408                                                          nsICSSDeclaration)

   410   virtual nsINode* GetParentObject() MOZ_OVERRIDE;

   412 protected:

   413   // This reference is not reference-counted. The rule object tells us

   414   // when it's about to go away.

   415   nsCSSKeyframeRule *mRule;

   416 };

   418 class nsCSSKeyframeRule MOZ_FINAL : public mozilla::css::Rule,

   419                                     public nsIDOMMozCSSKeyframeRule

   420 {

   421 public:

   422   // WARNING: Steals the contents of aKeys *and* aDeclaration

   423   nsCSSKeyframeRule(InfallibleTArray<float>& aKeys,

   424                     nsAutoPtr<mozilla::css::Declaration> aDeclaration)

   425     : mDeclaration(aDeclaration)

   426   {

   427     mKeys.SwapElements(aKeys);

   428   }

   429 private:

   430   nsCSSKeyframeRule(const nsCSSKeyframeRule& aCopy);

   431   ~nsCSSKeyframeRule();

   432 public:

   433   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

   434   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSKeyframeRule, nsIStyleRule)

   436   // nsIStyleRule methods

   437 #ifdef DEBUG

   438   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   439 #endif

   441   // Rule methods

   442   DECL_STYLE_RULE_INHERIT

   443   virtual int32_t GetType() const MOZ_OVERRIDE;

   444   virtual already_AddRefed<mozilla::css::Rule> Clone() const;

   446   // nsIDOMCSSRule interface

   447   NS_DECL_NSIDOMCSSRULE

   449   // nsIDOMMozCSSKeyframeRule interface

   450   NS_DECL_NSIDOMMOZCSSKEYFRAMERULE

   452   const nsTArray<float>& GetKeys() const     { return mKeys; }

   453   mozilla::css::Declaration* Declaration()   { return mDeclaration; }

   455   void ChangeDeclaration(mozilla::css::Declaration* aDeclaration);

   457   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;

   459   void DoGetKeyText(nsAString &aKeyText) const;

   461 private:

   462   nsTArray<float>                            mKeys;

   463   nsAutoPtr<mozilla::css::Declaration>       mDeclaration;

   464   // lazily created when needed:

   465   nsRefPtr<nsCSSKeyframeStyleDeclaration>    mDOMDeclaration;

   466 };

   468 class nsCSSKeyframesRule MOZ_FINAL : public mozilla::css::GroupRule,

   469                                      public nsIDOMMozCSSKeyframesRule

   470 {

   471 public:

   472   nsCSSKeyframesRule(const nsSubstring& aName)

   473     : mName(aName)

   474   {

   475   }

   476 private:

   477   nsCSSKeyframesRule(const nsCSSKeyframesRule& aCopy);

   478   ~nsCSSKeyframesRule();

   479 public:

   480   NS_DECL_ISUPPORTS_INHERITED

   482   // nsIStyleRule methods

   483 #ifdef DEBUG

   484   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   485 #endif

   487   // Rule methods

   488   virtual int32_t GetType() const;

   489   virtual already_AddRefed<mozilla::css::Rule> Clone() const;

   490   virtual nsIDOMCSSRule* GetDOMRule()

   491   {

   492     return this;

   493   }

   494   virtual nsIDOMCSSRule* GetExistingDOMRule()

   495   {

   496     return this;

   497   }

   499   // nsIDOMCSSRule interface

   500   NS_DECL_NSIDOMCSSRULE

   502   // nsIDOMMozCSSKeyframesRule interface

   503   NS_DECL_NSIDOMMOZCSSKEYFRAMESRULE

   505   // rest of GroupRule

   506   virtual bool UseForPresentation(nsPresContext* aPresContext,

   507                                     nsMediaQueryResultCacheKey& aKey) MOZ_OVERRIDE;

   509   const nsString& GetName() { return mName; }

   511   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;

   513 private:

   514   uint32_t FindRuleIndexForKey(const nsAString& aKey);

   516   nsString                                   mName;

   517 };

   519 class nsCSSPageRule;

   521 class nsCSSPageStyleDeclaration MOZ_FINAL : public nsDOMCSSDeclaration

   522 {

   523 public:

   524   nsCSSPageStyleDeclaration(nsCSSPageRule *aRule);

   525   virtual ~nsCSSPageStyleDeclaration();

   527   NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) MOZ_OVERRIDE;

   528   void DropReference() { mRule = nullptr; }

   529   virtual mozilla::css::Declaration* GetCSSDeclaration(bool aAllocate) MOZ_OVERRIDE;

   530   virtual nsresult SetCSSDeclaration(mozilla::css::Declaration* aDecl) MOZ_OVERRIDE;

   531   virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) MOZ_OVERRIDE;

   532   virtual nsIDocument* DocToUpdate() MOZ_OVERRIDE;

   534   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

   535   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSPageStyleDeclaration,

   536                                                          nsICSSDeclaration)

   538   virtual nsINode *GetParentObject() MOZ_OVERRIDE;

   540 protected:

   541   // This reference is not reference-counted. The rule object tells us

   542   // when it's about to go away.

   543   nsCSSPageRule *mRule;

   544 };

   546 class nsCSSPageRule MOZ_FINAL : public mozilla::css::Rule,

   547                                 public nsIDOMCSSPageRule

   548 {

   549 public:

   550   // WARNING: Steals the contents of aDeclaration

   551   nsCSSPageRule(nsAutoPtr<mozilla::css::Declaration> aDeclaration)

   552     : mDeclaration(aDeclaration),

   553       mImportantRule(nullptr)

   554   {

   555   }

   556 private:

   557   nsCSSPageRule(const nsCSSPageRule& aCopy);

   558   ~nsCSSPageRule();

   559 public:

   560   NS_DECL_CYCLE_COLLECTING_ISUPPORTS

   561   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSPageRule, nsIDOMCSSPageRule)

   563   // nsIStyleRule methods

   564 #ifdef DEBUG

   565   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   566 #endif

   568   // Rule methods

   569   DECL_STYLE_RULE_INHERIT

   570   virtual int32_t GetType() const MOZ_OVERRIDE;

   571   virtual already_AddRefed<mozilla::css::Rule> Clone() const;

   573   // nsIDOMCSSRule interface

   574   NS_DECL_NSIDOMCSSRULE

   576   // nsIDOMCSSPageRule interface

   577   NS_DECL_NSIDOMCSSPAGERULE

   579   mozilla::css::Declaration* Declaration()   { return mDeclaration; }

   581   void ChangeDeclaration(mozilla::css::Declaration* aDeclaration);

   583   mozilla::css::ImportantRule* GetImportantRule();

   585   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;

   586 private:

   587   nsAutoPtr<mozilla::css::Declaration>    mDeclaration;

   588   // lazily created when needed:

   589   nsRefPtr<nsCSSPageStyleDeclaration>     mDOMDeclaration;

   590   nsRefPtr<mozilla::css::ImportantRule>   mImportantRule;

   591 };

   593 namespace mozilla {

   595 class CSSSupportsRule : public css::GroupRule,

   596                         public nsIDOMCSSSupportsRule

   597 {

   598 public:

   599   CSSSupportsRule(bool aConditionMet, const nsString& aCondition);

   600   CSSSupportsRule(const CSSSupportsRule& aCopy);

   602   // nsIStyleRule methods

   603 #ifdef DEBUG

   604   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const MOZ_OVERRIDE;

   605 #endif

   607   // Rule methods

   608   virtual int32_t GetType() const;

   609   virtual already_AddRefed<mozilla::css::Rule> Clone() const;

   610   virtual bool UseForPresentation(nsPresContext* aPresContext,

   611                                   nsMediaQueryResultCacheKey& aKey);

   612   virtual nsIDOMCSSRule* GetDOMRule()

   613   {

   614     return this;

   615   }

   616   virtual nsIDOMCSSRule* GetExistingDOMRule()

   617   {

   618     return this;

   619   }

   621   NS_DECL_ISUPPORTS_INHERITED

   623   // nsIDOMCSSRule interface

   624   NS_DECL_NSIDOMCSSRULE

   626   // nsIDOMCSSGroupingRule interface

   627   NS_DECL_NSIDOMCSSGROUPINGRULE

   629   // nsIDOMCSSConditionRule interface

   630   NS_DECL_NSIDOMCSSCONDITIONRULE

   632   // nsIDOMCSSSupportsRule interface

   633   NS_DECL_NSIDOMCSSSUPPORTSRULE

   635   virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;

   637   static bool PrefEnabled()

   638   {

   639     return Preferences::GetBool("layout.css.supports-rule.enabled");

   640   }

   642 protected:

   643   bool mUseGroup;

   644   nsString mCondition;

   645 };

   647 } // namespace mozilla

   649 #endif /* !defined(nsCSSRules_h_) */

The Tor Browser / file revision

layout/style/nsCSSRules.h@8bccb770b82d

layout/style/nsCSSRules.h