diff --git a/dom/base/nsDOMClassInfo.cpp b/dom/base/nsDOMClassInfo.cpp index 34e6b82476..1ea93ed4ce 100644 --- a/dom/base/nsDOMClassInfo.cpp +++ b/dom/base/nsDOMClassInfo.cpp @@ -67,21 +67,10 @@ #include "nsIDOMEventTarget.h" // CSS related includes -#include "nsCSSRules.h" #include "nsIDOMCSSRule.h" #include "nsMemory.h" // includes needed for the prototype chain interfaces -#include "nsIDOMCSSKeyframeRule.h" -#include "nsIDOMCSSKeyframesRule.h" -#include "nsIDOMCSSImportRule.h" -#include "nsIDOMCSSMediaRule.h" -#include "nsIDOMCSSFontFaceRule.h" -#include "nsIDOMCSSMozDocumentRule.h" -#include "nsIDOMCSSSupportsRule.h" -#include "nsIDOMCSSCounterStyleRule.h" -#include "nsIDOMCSSPageRule.h" -#include "nsIDOMCSSStyleRule.h" #include "nsIDOMXULCommandDispatcher.h" #include "nsIControllers.h" #ifdef MOZ_XUL @@ -188,16 +177,6 @@ static nsDOMClassInfoData sClassInfoData[] = { // Misc Core related classes - // CSS classes - NS_DEFINE_CLASSINFO_DATA(CSSStyleRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CLASSINFO_DATA(CSSImportRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CLASSINFO_DATA(CSSMediaRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CLASSINFO_DATA(CSSNameSpaceRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - // XUL classes #ifdef MOZ_XUL NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULCommandDispatcher, nsDOMGenericSH, @@ -220,15 +199,6 @@ static nsDOMClassInfoData sClassInfoData[] = { DEFAULT_SCRIPTABLE_FLAGS) #endif - NS_DEFINE_CLASSINFO_DATA(CSSMozDocumentRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSSupportsRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSFontFaceRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ContentFrameMessageManager, nsMessageManagerSH, DOM_DEFAULT_SCRIPTABLE_FLAGS | @@ -244,21 +214,6 @@ static nsDOMClassInfoData sClassInfoData[] = { NS_DEFINE_CHROME_ONLY_CLASSINFO_DATA(ChromeMessageSender, nsDOMGenericSH, DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSKeyframeRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CLASSINFO_DATA(CSSKeyframesRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSCounterStyleRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSPageRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - - NS_DEFINE_CLASSINFO_DATA(CSSFontFeatureValuesRule, nsDOMGenericSH, - DOM_DEFAULT_SCRIPTABLE_FLAGS) - NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULControlElement, nsDOMGenericSH, DOM_DEFAULT_SCRIPTABLE_FLAGS) NS_DEFINE_CHROME_XBL_CLASSINFO_DATA(XULLabeledControlElement, nsDOMGenericSH, @@ -511,22 +466,6 @@ nsDOMClassInfo::Init() DOM_CLASSINFO_MAP_ENTRY(nsIDOMDOMConstructor) DOM_CLASSINFO_MAP_END - DOM_CLASSINFO_MAP_BEGIN(CSSStyleRule, nsIDOMCSSStyleRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSStyleRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSImportRule, nsIDOMCSSImportRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSImportRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSMediaRule, nsIDOMCSSMediaRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSMediaRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(CSSNameSpaceRule, nsIDOMCSSRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSRule) - DOM_CLASSINFO_MAP_END - #ifdef MOZ_XUL DOM_CLASSINFO_MAP_BEGIN(XULCommandDispatcher, nsIDOMXULCommandDispatcher) DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULCommandDispatcher) @@ -560,18 +499,6 @@ nsDOMClassInfo::Init() DOM_CLASSINFO_MAP_END #endif - DOM_CLASSINFO_MAP_BEGIN(CSSMozDocumentRule, nsIDOMCSSMozDocumentRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSMozDocumentRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSSupportsRule, nsIDOMCSSSupportsRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSSupportsRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSFontFaceRule, nsIDOMCSSFontFaceRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSFontFaceRule) - DOM_CLASSINFO_MAP_END - DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(ContentFrameMessageManager, nsISupports) DOM_CLASSINFO_MAP_ENTRY(nsIDOMEventTarget) DOM_CLASSINFO_MAP_ENTRY(nsIMessageListenerManager) @@ -603,26 +530,6 @@ nsDOMClassInfo::Init() DOM_CLASSINFO_MAP_ENTRY(nsIMessageSender) DOM_CLASSINFO_MAP_END - DOM_CLASSINFO_MAP_BEGIN(CSSKeyframeRule, nsIDOMCSSKeyframeRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSKeyframeRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSKeyframesRule, nsIDOMCSSKeyframesRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSKeyframesRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSCounterStyleRule, nsIDOMCSSCounterStyleRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSCounterStyleRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSPageRule, nsIDOMCSSPageRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSPageRule) - DOM_CLASSINFO_MAP_END - - DOM_CLASSINFO_MAP_BEGIN(CSSFontFeatureValuesRule, nsIDOMCSSFontFeatureValuesRule) - DOM_CLASSINFO_MAP_ENTRY(nsIDOMCSSFontFeatureValuesRule) - DOM_CLASSINFO_MAP_END - DOM_CLASSINFO_MAP_BEGIN_NO_CLASS_IF(XULControlElement, nsIDOMXULControlElement) DOM_CLASSINFO_MAP_ENTRY(nsIDOMXULControlElement) DOM_CLASSINFO_MAP_END diff --git a/dom/base/nsDOMClassInfoClasses.h b/dom/base/nsDOMClassInfoClasses.h index e381fb8f9b..843cdc85bf 100644 --- a/dom/base/nsDOMClassInfoClasses.h +++ b/dom/base/nsDOMClassInfoClasses.h @@ -7,12 +7,6 @@ DOMCI_CLASS(DOMPrototype) DOMCI_CLASS(DOMConstructor) -// CSS classes -DOMCI_CLASS(CSSStyleRule) -DOMCI_CLASS(CSSImportRule) -DOMCI_CLASS(CSSMediaRule) -DOMCI_CLASS(CSSNameSpaceRule) - // XUL classes #ifdef MOZ_XUL DOMCI_CLASS(XULCommandDispatcher) @@ -28,27 +22,11 @@ DOMCI_CLASS(XULTemplateBuilder) DOMCI_CLASS(XULTreeBuilder) #endif -DOMCI_CLASS(CSSMozDocumentRule) -DOMCI_CLASS(CSSSupportsRule) - -// @font-face in CSS -DOMCI_CLASS(CSSFontFaceRule) - DOMCI_CLASS(ContentFrameMessageManager) DOMCI_CLASS(ContentProcessMessageManager) DOMCI_CLASS(ChromeMessageBroadcaster) DOMCI_CLASS(ChromeMessageSender) -DOMCI_CLASS(CSSKeyframeRule) -DOMCI_CLASS(CSSKeyframesRule) - -// @counter-style in CSS -DOMCI_CLASS(CSSCounterStyleRule) - -DOMCI_CLASS(CSSPageRule) - -DOMCI_CLASS(CSSFontFeatureValuesRule) - DOMCI_CLASS(XULControlElement) DOMCI_CLASS(XULLabeledControlElement) DOMCI_CLASS(XULButtonElement) diff --git a/dom/base/nsDocument.cpp b/dom/base/nsDocument.cpp index 5f1d3a30c0..0c6950e422 100644 --- a/dom/base/nsDocument.cpp +++ b/dom/base/nsDocument.cpp @@ -4940,7 +4940,7 @@ nsDocument::StyleRuleChanged(StyleSheet* aSheet, DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent, "StyleRuleChanged", mRule, - aStyleRule ? aStyleRule->GetDOMRule() : nullptr); + aStyleRule); } } @@ -4954,8 +4954,7 @@ nsDocument::StyleRuleAdded(StyleSheet* aSheet, DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent, "StyleRuleAdded", mRule, - aStyleRule ? aStyleRule->GetDOMRule() - : nullptr); + aStyleRule); } } @@ -4969,8 +4968,7 @@ nsDocument::StyleRuleRemoved(StyleSheet* aSheet, DO_STYLESHEET_NOTIFICATION(StyleRuleChangeEvent, "StyleRuleRemoved", mRule, - aStyleRule ? aStyleRule->GetDOMRule() - : nullptr); + aStyleRule); } } diff --git a/dom/base/nsWrapperCache.h b/dom/base/nsWrapperCache.h index 8bdc1b93b6..8368581c96 100644 --- a/dom/base/nsWrapperCache.h +++ b/dom/base/nsWrapperCache.h @@ -19,6 +19,7 @@ class TabChildGlobal; class ProcessGlobal; } // namespace dom } // namespace mozilla + class SandboxPrivate; class nsInProcessTabChildGlobal; class nsWindowRoot; @@ -144,7 +145,7 @@ public: } } - bool PreservingWrapper() + bool PreservingWrapper() const { return HasWrapperFlag(WRAPPER_BIT_PRESERVED); } @@ -163,7 +164,7 @@ public: /** * Returns true if the object has a non-gray wrapper. */ - bool IsBlack(); + bool IsBlack() const; /** * Returns true if the object has a black wrapper, @@ -271,11 +272,15 @@ protected: } private: + // Friend declarations for things that need to be able to call + // SetIsNotDOMBinding(). The goal is to get rid of all of these, and + // SetIsNotDOMBinding() too. friend class mozilla::dom::TabChildGlobal; friend class mozilla::dom::ProcessGlobal; friend class SandboxPrivate; friend class nsInProcessTabChildGlobal; friend class nsWindowRoot; + void SetIsNotDOMBinding() { MOZ_ASSERT(!mWrapper && !(GetWrapperFlags() & ~WRAPPER_IS_NOT_DOM_BINDING), diff --git a/dom/base/nsWrapperCacheInlines.h b/dom/base/nsWrapperCacheInlines.h index 2576c02ecd..d9b0ff6b8d 100644 --- a/dom/base/nsWrapperCacheInlines.h +++ b/dom/base/nsWrapperCacheInlines.h @@ -21,7 +21,7 @@ nsWrapperCache::GetWrapper() const } inline bool -nsWrapperCache::IsBlack() +nsWrapperCache::IsBlack() const { JSObject* o = GetWrapperPreserveColor(); return o && !JS::ObjectIsMarkedGray(o); diff --git a/dom/bindings/Bindings.conf b/dom/bindings/Bindings.conf index 26751ac8c6..f484c59e53 100644 --- a/dom/bindings/Bindings.conf +++ b/dom/bindings/Bindings.conf @@ -197,23 +197,96 @@ DOMInterfaces = { 'nativeType': 'nsDOMCSSDeclaration' }, +'CSSConditionRule': { + 'concrete': False, + 'nativeType': 'mozilla::css::ConditionRule', + 'headerFile': 'mozilla/css/GroupRule.h', +}, + +'CSSCounterStyleRule': { + 'nativeType': 'nsCSSCounterStyleRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSFontFaceRule': { + 'nativeType': 'nsCSSFontFaceRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSFontFeatureValuesRule': { + 'nativeType': 'nsCSSFontFeatureValuesRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSGroupingRule': { + 'concrete': False, + 'nativeType': 'mozilla::css::GroupRule', +}, + +'CSSImportRule': { + 'nativeType': 'mozilla::css::ImportRule', +}, + +'CSSKeyframeRule': { + 'nativeType': 'nsCSSKeyframeRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSKeyframesRule': { + 'nativeType': 'nsCSSKeyframesRule', + 'headerFile': 'nsCSSRules.h', +}, + 'CSSLexer': { 'wrapperCache': False }, +'CSSMediaRule': { + 'nativeType': 'mozilla::css::MediaRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSMozDocumentRule': { + 'nativeType': 'mozilla::css::DocumentRule', + 'headerFile': 'nsCSSRules.h', +}, + +'CSSNamespaceRule': { + 'nativeType': 'mozilla::css::NameSpaceRule', +}, + +'CSSPageRule': { + 'nativeType': 'nsCSSPageRule', + 'headerFile': 'nsCSSRules.h', +}, + 'CSSPrimitiveValue': { 'nativeType': 'nsROCSSPrimitiveValue', }, +'CSSRule': { + 'concrete': False, + 'nativeType': 'mozilla::css::Rule' +}, + 'CSSStyleDeclaration': { 'nativeType': 'nsICSSDeclaration' }, +'CSSStyleRule': { + 'nativeType': 'mozilla::BindingStyleRule', +}, + 'CSSStyleSheet': { 'nativeType': 'mozilla::StyleSheet', 'binaryNames': { 'ownerRule': 'DOMOwnerRule' }, }, +'CSSSupportsRule': { + 'nativeType': 'mozilla::CSSSupportsRule', + 'headerFile': 'nsCSSRules.h', +}, + 'CSSValue': { 'concrete': False }, @@ -1689,7 +1762,6 @@ def addExternalIface(iface, nativeType=None, headerFile=None, addExternalIface('ApplicationCache', nativeType='nsIDOMOfflineResourceList') addExternalIface('Counter') -addExternalIface('CSSRule') addExternalIface('RTCDataChannel', nativeType='nsIDOMDataChannel') addExternalIface('HitRegionOptions', nativeType='nsISupports') addExternalIface('imgINotificationObserver', nativeType='imgINotificationObserver') diff --git a/dom/interfaces/css/nsIDOMCSSCounterStyleRule.idl b/dom/interfaces/css/nsIDOMCSSCounterStyleRule.idl index d82b4dbc44..eb2c58d943 100644 --- a/dom/interfaces/css/nsIDOMCSSCounterStyleRule.idl +++ b/dom/interfaces/css/nsIDOMCSSCounterStyleRule.idl @@ -3,10 +3,10 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" [scriptable, uuid(9b5e48ce-d84c-4e31-aff5-34e9f4141313)] -interface nsIDOMCSSCounterStyleRule : nsIDOMCSSRule +interface nsIDOMCSSCounterStyleRule : nsISupports { attribute DOMString name; attribute DOMString system; diff --git a/dom/interfaces/css/nsIDOMCSSFontFaceRule.idl b/dom/interfaces/css/nsIDOMCSSFontFaceRule.idl index 18ca669f43..06a58bb834 100644 --- a/dom/interfaces/css/nsIDOMCSSFontFaceRule.idl +++ b/dom/interfaces/css/nsIDOMCSSFontFaceRule.idl @@ -3,10 +3,12 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSStyleDeclaration; [scriptable, uuid(db971017-fe0c-4529-972c-8217f2fee217)] -interface nsIDOMCSSFontFaceRule : nsIDOMCSSRule +interface nsIDOMCSSFontFaceRule : nsISupports { readonly attribute nsIDOMCSSStyleDeclaration style; }; diff --git a/dom/interfaces/css/nsIDOMCSSFontFeatureValuesRule.idl b/dom/interfaces/css/nsIDOMCSSFontFeatureValuesRule.idl index 1b04dde86f..1e782c07db 100644 --- a/dom/interfaces/css/nsIDOMCSSFontFeatureValuesRule.idl +++ b/dom/interfaces/css/nsIDOMCSSFontFeatureValuesRule.idl @@ -3,10 +3,10 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" [scriptable, uuid(a343d27f-1da6-4fc3-9355-d4ca434f958e)] -interface nsIDOMCSSFontFeatureValuesRule : nsIDOMCSSRule +interface nsIDOMCSSFontFeatureValuesRule : nsISupports { attribute DOMString fontFamily; // raises(DOMException) on setting diff --git a/dom/interfaces/css/nsIDOMCSSGroupingRule.idl b/dom/interfaces/css/nsIDOMCSSGroupingRule.idl index f3580aeecc..348af52b5d 100644 --- a/dom/interfaces/css/nsIDOMCSSGroupingRule.idl +++ b/dom/interfaces/css/nsIDOMCSSGroupingRule.idl @@ -3,13 +3,15 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSRuleList; /** * Interface for at-rules that have child rules in the CSS OM. */ [scriptable, uuid(a0e3324a-f911-4baf-9591-5322c76cbb0d)] -interface nsIDOMCSSGroupingRule : nsIDOMCSSRule +interface nsIDOMCSSGroupingRule : nsISupports { readonly attribute nsIDOMCSSRuleList cssRules; diff --git a/dom/interfaces/css/nsIDOMCSSImportRule.idl b/dom/interfaces/css/nsIDOMCSSImportRule.idl index 0909d92212..fc96977d91 100644 --- a/dom/interfaces/css/nsIDOMCSSImportRule.idl +++ b/dom/interfaces/css/nsIDOMCSSImportRule.idl @@ -3,10 +3,13 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMMediaList; +interface nsIDOMCSSStyleSheet; [scriptable, uuid(d3b2b914-01ef-4663-beda-a6475a26f491)] -interface nsIDOMCSSImportRule : nsIDOMCSSRule +interface nsIDOMCSSImportRule : nsISupports { readonly attribute DOMString href; readonly attribute nsIDOMMediaList media; diff --git a/dom/interfaces/css/nsIDOMCSSKeyframeRule.idl b/dom/interfaces/css/nsIDOMCSSKeyframeRule.idl index 46e7ffbb10..0027be2d29 100644 --- a/dom/interfaces/css/nsIDOMCSSKeyframeRule.idl +++ b/dom/interfaces/css/nsIDOMCSSKeyframeRule.idl @@ -3,10 +3,12 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSStyleDeclaration; [scriptable, uuid(a281a8b4-eaa2-49a8-8b97-acc2814a57c9)] -interface nsIDOMCSSKeyframeRule : nsIDOMCSSRule +interface nsIDOMCSSKeyframeRule : nsISupports { attribute DOMString keyText; readonly attribute nsIDOMCSSStyleDeclaration style; diff --git a/dom/interfaces/css/nsIDOMCSSKeyframesRule.idl b/dom/interfaces/css/nsIDOMCSSKeyframesRule.idl index acbb657e47..0e2d3bc4f2 100644 --- a/dom/interfaces/css/nsIDOMCSSKeyframesRule.idl +++ b/dom/interfaces/css/nsIDOMCSSKeyframesRule.idl @@ -3,10 +3,13 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSRuleList; +interface nsIDOMCSSKeyframeRule; [scriptable, uuid(400f4b70-ad0a-4047-aba4-ee8019f6b907)] -interface nsIDOMCSSKeyframesRule : nsIDOMCSSRule +interface nsIDOMCSSKeyframesRule : nsISupports { attribute DOMString name; readonly attribute nsIDOMCSSRuleList cssRules; diff --git a/dom/interfaces/css/nsIDOMCSSMediaRule.idl b/dom/interfaces/css/nsIDOMCSSMediaRule.idl index 9be4ba143a..e292e2485f 100644 --- a/dom/interfaces/css/nsIDOMCSSMediaRule.idl +++ b/dom/interfaces/css/nsIDOMCSSMediaRule.idl @@ -5,6 +5,8 @@ #include "nsIDOMCSSConditionRule.idl" +interface nsIDOMMediaList; + /** * Interface for @media rules in the CSS OM. */ diff --git a/dom/interfaces/css/nsIDOMCSSPageRule.idl b/dom/interfaces/css/nsIDOMCSSPageRule.idl index e586a0dbb3..a7efb5044a 100644 --- a/dom/interfaces/css/nsIDOMCSSPageRule.idl +++ b/dom/interfaces/css/nsIDOMCSSPageRule.idl @@ -3,10 +3,12 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSStyleDeclaration; [scriptable, uuid(c119072b-7d2f-4aeb-a90d-e2d6b606c32a)] -interface nsIDOMCSSPageRule : nsIDOMCSSRule +interface nsIDOMCSSPageRule : nsISupports { //attribute DOMString selectorText; // raises(DOMException) on setting diff --git a/dom/interfaces/css/nsIDOMCSSStyleRule.idl b/dom/interfaces/css/nsIDOMCSSStyleRule.idl index d94d22d93e..39b3efaf0c 100644 --- a/dom/interfaces/css/nsIDOMCSSStyleRule.idl +++ b/dom/interfaces/css/nsIDOMCSSStyleRule.idl @@ -3,10 +3,12 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" + +interface nsIDOMCSSStyleDeclaration; [scriptable, uuid(b5e9af48-a7c2-4f88-aae3-58307af4b5a5)] -interface nsIDOMCSSStyleRule : nsIDOMCSSRule +interface nsIDOMCSSStyleRule : nsISupports { attribute DOMString selectorText; // raises(DOMException) on setting diff --git a/dom/interfaces/css/nsIDOMCSSUnknownRule.idl b/dom/interfaces/css/nsIDOMCSSUnknownRule.idl index 6dfb5ec69a..87546d63b5 100644 --- a/dom/interfaces/css/nsIDOMCSSUnknownRule.idl +++ b/dom/interfaces/css/nsIDOMCSSUnknownRule.idl @@ -3,9 +3,9 @@ * 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 "nsIDOMCSSRule.idl" +#include "nsISupports.idl" [scriptable, uuid(98f4c27b-fb35-4355-8fd9-546c4697d71a)] -interface nsIDOMCSSUnknownRule : nsIDOMCSSRule +interface nsIDOMCSSUnknownRule : nsISupports { }; diff --git a/dom/media/webaudio/AudioBuffer.h b/dom/media/webaudio/AudioBuffer.h index 15474b6c5c..e8722db77b 100644 --- a/dom/media/webaudio/AudioBuffer.h +++ b/dom/media/webaudio/AudioBuffer.h @@ -15,6 +15,7 @@ #include "AudioContext.h" #include "js/TypeDecls.h" #include "mozilla/MemoryReporting.h" +#include "mozilla/dom/TypedArray.h" namespace mozilla { diff --git a/dom/tests/mochitest/general/test_interfaces.html b/dom/tests/mochitest/general/test_interfaces.html index 1354f381e9..13a76ce992 100644 --- a/dom/tests/mochitest/general/test_interfaces.html +++ b/dom/tests/mochitest/general/test_interfaces.html @@ -244,7 +244,7 @@ var interfaceNamesInGlobalScope = // IMPORTANT: Do not change this list without review from a DOM peer! "CSSMozDocumentRule", // IMPORTANT: Do not change this list without review from a DOM peer! - "CSSNameSpaceRule", + "CSSNamespaceRule", // IMPORTANT: Do not change this list without review from a DOM peer! "CSSPageRule", // IMPORTANT: Do not change this list without review from a DOM peer! diff --git a/dom/url/URL.h b/dom/url/URL.h index a0afd8b8b6..53164b7b95 100644 --- a/dom/url/URL.h +++ b/dom/url/URL.h @@ -55,6 +55,14 @@ public: Constructor(const GlobalObject& aGlobal, const nsAString& aURL, const Optional& aBase, ErrorResult& aRv); + // Helper for window.URL constructor + static already_AddRefed + WebkitURL(const GlobalObject& aGlobal, const nsAString& aURL, + const Optional& aBase, ErrorResult& aRv) + { + return Constructor(aGlobal, aURL, aBase, aRv); + } + // Helper for Fetch API static already_AddRefed WorkerConstructor(const GlobalObject& aGlobal, const nsAString& aURL, diff --git a/dom/webidl/CSSConditionRule.webidl b/dom/webidl/CSSConditionRule.webidl new file mode 100644 index 0000000000..24fae2343c --- /dev/null +++ b/dom/webidl/CSSConditionRule.webidl @@ -0,0 +1,14 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-conditional/#the-cssconditionrule-interface + */ + +// https://drafts.csswg.org/css-conditional/#the-cssconditionrule-interface +interface CSSConditionRule : CSSGroupingRule { + [SetterThrows] + attribute DOMString conditionText; +}; diff --git a/dom/webidl/CSSCounterStyleRule.webidl b/dom/webidl/CSSCounterStyleRule.webidl new file mode 100644 index 0000000000..bb6f7e0e1b --- /dev/null +++ b/dom/webidl/CSSCounterStyleRule.webidl @@ -0,0 +1,23 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-counter-styles-3/#the-csscounterstylerule-interface + */ + +// https://drafts.csswg.org/css-counter-styles-3/#the-csscounterstylerule-interface +interface CSSCounterStyleRule : CSSRule { + attribute DOMString name; + attribute DOMString system; + attribute DOMString symbols; + attribute DOMString additiveSymbols; + attribute DOMString negative; + attribute DOMString prefix; + attribute DOMString suffix; + attribute DOMString range; + attribute DOMString pad; + attribute DOMString speakAs; + attribute DOMString fallback; +}; diff --git a/dom/webidl/CSSFontFaceRule.webidl b/dom/webidl/CSSFontFaceRule.webidl new file mode 100644 index 0000000000..221dd26aec --- /dev/null +++ b/dom/webidl/CSSFontFaceRule.webidl @@ -0,0 +1,15 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-fonts/#om-fontface + */ + +// https://drafts.csswg.org/css-fonts/#om-fontface +// But we implement a very old draft, apparently.... +// See bug 1058408 for implementing the current spec. +interface CSSFontFaceRule : CSSRule { + [SameObject] readonly attribute CSSStyleDeclaration style; +}; diff --git a/dom/webidl/CSSFontFeatureValuesRule.webidl b/dom/webidl/CSSFontFeatureValuesRule.webidl new file mode 100644 index 0000000000..7532938141 --- /dev/null +++ b/dom/webidl/CSSFontFeatureValuesRule.webidl @@ -0,0 +1,29 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-fonts/#om-fontfeaturevalues + */ + +// https://drafts.csswg.org/css-fonts/#om-fontfeaturevalues +// but we don't implement anything remotely resembling the spec. +interface CSSFontFeatureValuesRule : CSSRule { + [SetterThrows] + attribute DOMString fontFamily; + + // Not yet implemented + // readonly attribute CSSFontFeatureValuesMap annotation; + // readonly attribute CSSFontFeatureValuesMap ornaments; + // readonly attribute CSSFontFeatureValuesMap stylistic; + // readonly attribute CSSFontFeatureValuesMap swash; + // readonly attribute CSSFontFeatureValuesMap characterVariant; + // readonly attribute CSSFontFeatureValuesMap styleset; +}; + +partial interface CSSFontFeatureValuesRule { + // Gecko addition? + [SetterThrows] + attribute DOMString valueText; +}; diff --git a/dom/webidl/CSSGroupingRule.webidl b/dom/webidl/CSSGroupingRule.webidl new file mode 100644 index 0000000000..bc1023fe20 --- /dev/null +++ b/dom/webidl/CSSGroupingRule.webidl @@ -0,0 +1,17 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#cssgroupingrule + */ + +// https://drafts.csswg.org/cssom/#cssgroupingrule +interface CSSGroupingRule : CSSRule { + [SameObject] readonly attribute CSSRuleList cssRules; + [Throws] + unsigned long insertRule(DOMString rule, unsigned long index); + [Throws] + void deleteRule(unsigned long index); +}; diff --git a/dom/webidl/CSSImportRule.webidl b/dom/webidl/CSSImportRule.webidl new file mode 100644 index 0000000000..7d3f17c794 --- /dev/null +++ b/dom/webidl/CSSImportRule.webidl @@ -0,0 +1,17 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#cssimportrule + */ + +// https://drafts.csswg.org/cssom/#cssimportrule +interface CSSImportRule : CSSRule { + readonly attribute DOMString href; + [SameObject, PutForwards=mediaText] readonly attribute MediaList media; + // Per spec, the .styleSheet is never null, but in our implementation it can + // be. See . + [SameObject] readonly attribute CSSStyleSheet? styleSheet; +}; diff --git a/dom/webidl/CSSKeyframeRule.webidl b/dom/webidl/CSSKeyframeRule.webidl new file mode 100644 index 0000000000..25d8965f2a --- /dev/null +++ b/dom/webidl/CSSKeyframeRule.webidl @@ -0,0 +1,14 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-animations/#interface-csskeyframerule + */ + +// https://drafts.csswg.org/css-animations/#interface-csskeyframerule +interface CSSKeyframeRule : CSSRule { + attribute DOMString keyText; + readonly attribute CSSStyleDeclaration style; +}; diff --git a/dom/webidl/CSSKeyframesRule.webidl b/dom/webidl/CSSKeyframesRule.webidl new file mode 100644 index 0000000000..d0ea978d03 --- /dev/null +++ b/dom/webidl/CSSKeyframesRule.webidl @@ -0,0 +1,18 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-animations/#interface-csskeyframesrule + */ + +// https://drafts.csswg.org/css-animations/#interface-csskeyframesrule +interface CSSKeyframesRule : CSSRule { + attribute DOMString name; + readonly attribute CSSRuleList cssRules; + + void appendRule(DOMString rule); + void deleteRule(DOMString select); + CSSKeyframeRule? findRule(DOMString select); +}; diff --git a/dom/webidl/CSSMediaRule.webidl b/dom/webidl/CSSMediaRule.webidl new file mode 100644 index 0000000000..841a1b6f6b --- /dev/null +++ b/dom/webidl/CSSMediaRule.webidl @@ -0,0 +1,17 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#the-cssmediarule-interface + * https://drafts.csswg.org/css-conditional/#the-cssmediarule-interface + */ + +// https://drafts.csswg.org/cssom/#the-cssmediarule-interface and +// https://drafts.csswg.org/css-conditional/#the-cssmediarule-interface +// except they disagree with each other. We're taking the inheritance from +// css-conditional and the PutForwards behavior from cssom. +interface CSSMediaRule : CSSConditionRule { + [SameObject, PutForwards=mediaText] readonly attribute MediaList media; +}; diff --git a/dom/webidl/CSSMozDocumentRule.webidl b/dom/webidl/CSSMozDocumentRule.webidl new file mode 100644 index 0000000000..27a22d52c7 --- /dev/null +++ b/dom/webidl/CSSMozDocumentRule.webidl @@ -0,0 +1,10 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + */ + +// This is a non-standard interface for @-moz-document rules +interface CSSMozDocumentRule : CSSConditionRule { + // XXX Add access to the URL list. +}; diff --git a/dom/webidl/CSSNamespaceRule.webidl b/dom/webidl/CSSNamespaceRule.webidl new file mode 100644 index 0000000000..0051c904a7 --- /dev/null +++ b/dom/webidl/CSSNamespaceRule.webidl @@ -0,0 +1,16 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#cssnamespacerule + */ + +// https://drafts.csswg.org/cssom/#cssnamespacerule +interface CSSNamespaceRule : CSSRule { + // Not implemented yet. . + // readonly attribute DOMString namespaceURI; + // readonly attribute DOMString prefix; +}; diff --git a/dom/webidl/CSSPageRule.webidl b/dom/webidl/CSSPageRule.webidl new file mode 100644 index 0000000000..93e47ef02b --- /dev/null +++ b/dom/webidl/CSSPageRule.webidl @@ -0,0 +1,17 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#the-csspagerule-interface + */ + +// https://drafts.csswg.org/cssom/#the-csspagerule-interface +// Per spec, this should inherit from CSSGroupingRule, but we don't +// implement this yet. +interface CSSPageRule : CSSRule { + // selectorText not implemented yet + // attribute DOMString selectorText; + [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style; +}; diff --git a/dom/webidl/CSSRule.webidl b/dom/webidl/CSSRule.webidl new file mode 100644 index 0000000000..6c4dac2e62 --- /dev/null +++ b/dom/webidl/CSSRule.webidl @@ -0,0 +1,52 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#the-cssrule-interface + * https://drafts.csswg.org/css-animations/#interface-cssrule + * https://drafts.csswg.org/css-counter-styles-3/#extentions-to-cssrule-interface + * https://drafts.csswg.org/css-conditional-3/#extentions-to-cssrule-interface + * https://drafts.csswg.org/css-fonts-3/#om-fontfeaturevalues + */ + +// https://drafts.csswg.org/cssom/#the-cssrule-interface +interface CSSRule { + + const unsigned short STYLE_RULE = 1; + const unsigned short CHARSET_RULE = 2; // historical + const unsigned short IMPORT_RULE = 3; + const unsigned short MEDIA_RULE = 4; + const unsigned short FONT_FACE_RULE = 5; + const unsigned short PAGE_RULE = 6; + // FIXME: We don't support MARGIN_RULE yet. + // XXXbz Should we expose the constant anyway? + // const unsigned short MARGIN_RULE = 9; + const unsigned short NAMESPACE_RULE = 10; + readonly attribute unsigned short type; + attribute DOMString cssText; + readonly attribute CSSRule? parentRule; + readonly attribute CSSStyleSheet? parentStyleSheet; +}; + +// https://drafts.csswg.org/css-animations/#interface-cssrule +partial interface CSSRule { + const unsigned short KEYFRAMES_RULE = 7; + const unsigned short KEYFRAME_RULE = 8; +}; + +// https://drafts.csswg.org/css-counter-styles-3/#extentions-to-cssrule-interface +partial interface CSSRule { + const unsigned short COUNTER_STYLE_RULE = 11; +}; + +// https://drafts.csswg.org/css-conditional-3/#extentions-to-cssrule-interface +partial interface CSSRule { + const unsigned short SUPPORTS_RULE = 12; +}; + +// https://drafts.csswg.org/css-fonts-3/#om-fontfeaturevalues +partial interface CSSRule { + const unsigned short FONT_FEATURE_VALUES_RULE = 14; +}; diff --git a/dom/webidl/CSSStyleDeclaration.webidl b/dom/webidl/CSSStyleDeclaration.webidl index 561e5cce1b..b672c0dd31 100644 --- a/dom/webidl/CSSStyleDeclaration.webidl +++ b/dom/webidl/CSSStyleDeclaration.webidl @@ -7,8 +7,6 @@ * http://dev.w3.org/csswg/cssom/ */ -interface CSSRule; - interface CSSStyleDeclaration { [CEReactions, SetterThrows] attribute DOMString cssText; diff --git a/dom/webidl/CSSStyleRule.webidl b/dom/webidl/CSSStyleRule.webidl new file mode 100644 index 0000000000..571bd6a57f --- /dev/null +++ b/dom/webidl/CSSStyleRule.webidl @@ -0,0 +1,14 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/cssom/#the-cssstylerule-interface + */ + +// https://drafts.csswg.org/cssom/#the-cssstylerule-interface +interface CSSStyleRule : CSSRule { + attribute DOMString selectorText; + [SameObject, PutForwards=cssText] readonly attribute CSSStyleDeclaration style; +}; diff --git a/dom/webidl/CSSStyleSheet.webidl b/dom/webidl/CSSStyleSheet.webidl index 677d3ec528..45ef840208 100644 --- a/dom/webidl/CSSStyleSheet.webidl +++ b/dom/webidl/CSSStyleSheet.webidl @@ -7,8 +7,6 @@ * http://dev.w3.org/csswg/cssom/ */ -interface CSSRule; - enum CSSStyleSheetParsingMode { "author", "user", diff --git a/dom/webidl/CSSSupportsRule.webidl b/dom/webidl/CSSSupportsRule.webidl new file mode 100644 index 0000000000..0576e90ebd --- /dev/null +++ b/dom/webidl/CSSSupportsRule.webidl @@ -0,0 +1,12 @@ +/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. + * + * The origin of this IDL file is + * https://drafts.csswg.org/css-conditional/#the-csssupportsrule-interface + */ + +// https://drafts.csswg.org/css-conditional/#the-csssupportsrule-interface +interface CSSSupportsRule : CSSConditionRule { +}; diff --git a/dom/webidl/LegacyQueryInterface.webidl b/dom/webidl/LegacyQueryInterface.webidl index 96048b03ca..a2f7b9dc64 100644 --- a/dom/webidl/LegacyQueryInterface.webidl +++ b/dom/webidl/LegacyQueryInterface.webidl @@ -24,8 +24,10 @@ BoxObject implements LegacyQueryInterface; CaretPosition implements LegacyQueryInterface; Comment implements LegacyQueryInterface; Crypto implements LegacyQueryInterface; +CSSMozDocumentRule implements LegacyQueryInterface; CSSPrimitiveValue implements LegacyQueryInterface; CSSStyleDeclaration implements LegacyQueryInterface; +CSSStyleRule implements LegacyQueryInterface; CSSValueList implements LegacyQueryInterface; DOMImplementation implements LegacyQueryInterface; DOMParser implements LegacyQueryInterface; diff --git a/dom/webidl/StyleRuleChangeEvent.webidl b/dom/webidl/StyleRuleChangeEvent.webidl index 0b783366ba..ef35bae648 100644 --- a/dom/webidl/StyleRuleChangeEvent.webidl +++ b/dom/webidl/StyleRuleChangeEvent.webidl @@ -3,8 +3,6 @@ * 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/. */ -interface CSSRule; - [ChromeOnly, Constructor(DOMString type, optional StyleRuleChangeEventInit eventInitDict)] interface StyleRuleChangeEvent : Event { diff --git a/dom/webidl/StyleSheet.webidl b/dom/webidl/StyleSheet.webidl index 71a8ccd8f4..26c2fbb999 100644 --- a/dom/webidl/StyleSheet.webidl +++ b/dom/webidl/StyleSheet.webidl @@ -7,8 +7,6 @@ * http://dev.w3.org/csswg/cssom/ */ -interface CSSRule; - interface StyleSheet { [Constant] readonly attribute DOMString type; diff --git a/dom/webidl/URL.webidl b/dom/webidl/URL.webidl index 4d491e1b36..a12635ce3f 100644 --- a/dom/webidl/URL.webidl +++ b/dom/webidl/URL.webidl @@ -15,6 +15,7 @@ // [Constructor(DOMString url, optional (URL or DOMString) base = "about:blank")] [Constructor(DOMString url, URL base), Constructor(DOMString url, optional DOMString base), + NamedConstructor=webkitURL(DOMString url, optional DOMString base), Exposed=(Window,Worker,WorkerDebugger)] interface URL { // Bug 824857: no support for stringifier attributes yet. diff --git a/dom/webidl/moz.build b/dom/webidl/moz.build index 27f55025ce..1d354fa3ed 100644 --- a/dom/webidl/moz.build +++ b/dom/webidl/moz.build @@ -90,12 +90,27 @@ WEBIDL_FILES = [ 'CSPReport.webidl', 'CSS.webidl', 'CSSAnimation.webidl', + 'CSSConditionRule.webidl', + 'CSSCounterStyleRule.webidl', + 'CSSFontFaceRule.webidl', + 'CSSFontFeatureValuesRule.webidl', + 'CSSGroupingRule.webidl', + 'CSSImportRule.webidl', + 'CSSKeyframeRule.webidl', + 'CSSKeyframesRule.webidl', 'CSSLexer.webidl', + 'CSSMediaRule.webidl', + 'CSSMozDocumentRule.webidl', + 'CSSNamespaceRule.webidl', + 'CSSPageRule.webidl', 'CSSPrimitiveValue.webidl', 'CSSPseudoElement.webidl', + 'CSSRule.webidl', 'CSSRuleList.webidl', 'CSSStyleDeclaration.webidl', + 'CSSStyleRule.webidl', 'CSSStyleSheet.webidl', + 'CSSSupportsRule.webidl', 'CSSTransition.webidl', 'CSSValue.webidl', 'CSSValueList.webidl', diff --git a/js/xpconnect/tests/chrome/test_weakmaps.xul b/js/xpconnect/tests/chrome/test_weakmaps.xul index e741a41c6c..9301b7b5d4 100644 --- a/js/xpconnect/tests/chrome/test_weakmaps.xul +++ b/js/xpconnect/tests/chrome/test_weakmaps.xul @@ -214,28 +214,8 @@ https://bugzilla.mozilla.org/show_bug.cgi?id=668855 make_live_map(); - let unpreservable_native_key = function () { - // We only allow natives that support wrapper preservation to be used as weak - // map keys. We should be able to try to add unpreservable natives as keys without - // crashing (bug 711616), but we should throw an error (bug 761620). - - let dummy_test_map = new WeakMap; - - let rule_fail = false; - let got_rule = false; - try { - var rule = document.styleSheets[0].cssRules[0]; - got_rule = true; - dummy_test_map.set(rule, 1); - } catch (e) { - rule_fail = true; - } - ok(got_rule, "Got the CSS rule"); - ok(rule_fail, "Using a CSS rule as a weak map key should produce an exception because it can't be wrapper preserved."); - - } - - unpreservable_native_key(); + // We're out of ideas for unpreservable natives, now that just about + // everything is on webidl, so just don't test those. /* set up for running precise GC/CC then checking the results */ diff --git a/js/xpconnect/tests/mochitest/file_crosscompartment_weakmap.html b/js/xpconnect/tests/mochitest/file_crosscompartment_weakmap.html index b25cdb2f90..127c479ebe 100644 --- a/js/xpconnect/tests/mochitest/file_crosscompartment_weakmap.html +++ b/js/xpconnect/tests/mochitest/file_crosscompartment_weakmap.html @@ -1,7 +1,6 @@ - Test Cross-Compartment DOM WeakMaps diff --git a/js/xpconnect/tests/mochitest/test_crosscompartment_weakmap.html b/js/xpconnect/tests/mochitest/test_crosscompartment_weakmap.html index e50b1f1bd8..54658d17bc 100644 --- a/js/xpconnect/tests/mochitest/test_crosscompartment_weakmap.html +++ b/js/xpconnect/tests/mochitest/test_crosscompartment_weakmap.html @@ -15,14 +15,6 @@ function setup() { var item = window.frames[0].document.querySelector("body"); my_map.set(item, "success_string"); - - var rule_fail = false; - try { - my_map.set(window.frames[0].document.styleSheets[0].cssRules[0], 1); - } catch (e) { - rule_fail = true; - } - ok(rule_fail, "Using rule as a weak map key across compartments should produce an exception because it can't be wrapper preserved."); } function runTest() { diff --git a/layout/inspector/inCSSValueSearch.cpp b/layout/inspector/inCSSValueSearch.cpp index ecde099938..5897e1b542 100644 --- a/layout/inspector/inCSSValueSearch.cpp +++ b/layout/inspector/inCSSValueSearch.cpp @@ -18,6 +18,7 @@ #include "nsIDOMCSSImportRule.h" #include "nsIDOMCSSMediaRule.h" #include "nsIDOMCSSSupportsRule.h" +#include "nsIDOMCSSRule.h" #include "nsIURI.h" #include "nsIDocument.h" #include "nsNetUtil.h" diff --git a/layout/inspector/inDOMUtils.cpp b/layout/inspector/inDOMUtils.cpp index 5e0cb208a8..fdae4543ed 100644 --- a/layout/inspector/inDOMUtils.cpp +++ b/layout/inspector/inDOMUtils.cpp @@ -248,13 +248,9 @@ inDOMUtils::GetCSSStyleRules(nsIDOMElement *aElement, for (nsRuleNode* ruleNode : Reversed(ruleNodes)) { RefPtr decl = do_QueryObject(ruleNode->GetRule()); if (decl) { - RefPtr styleRule = - do_QueryObject(decl->GetOwningRule()); - if (styleRule) { - nsCOMPtr domRule = styleRule->GetDOMRule(); - if (domRule) { - rules->AppendElement(domRule, /*weak =*/ false); - } + css::Rule* owningRule = decl->GetOwningRule(); + if (owningRule) { + rules->AppendElement(owningRule, /*weak =*/ false); } } } diff --git a/layout/style/BindingStyleRule.cpp b/layout/style/BindingStyleRule.cpp new file mode 100644 index 0000000000..9cdbc46cdd --- /dev/null +++ b/layout/style/BindingStyleRule.cpp @@ -0,0 +1,18 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */ + +#include "mozilla/BindingStyleRule.h" +#include "mozilla/dom/CSSStyleRuleBinding.h" + +namespace mozilla { + +/* virtual */ JSObject* +BindingStyleRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return dom::CSSStyleRuleBinding::Wrap(aCx, this, aGivenProto); +} + +} // namespace mozilla diff --git a/layout/style/BindingStyleRule.h b/layout/style/BindingStyleRule.h new file mode 100644 index 0000000000..e371bc1149 --- /dev/null +++ b/layout/style/BindingStyleRule.h @@ -0,0 +1,60 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */ + +#ifndef mozilla_BindingStyleRule_h__ +#define mozilla_BindingStyleRule_h__ + +#include "nscore.h" +#include "nsStringGlue.h" +#include "mozilla/css/Rule.h" + +/** + * Superclass for mozilla::css::StyleRule, for use from bindings code. + */ + +class nsICSSDeclaration; + +namespace mozilla { + +class BindingStyleRule : public css::Rule +{ +protected: + BindingStyleRule(uint32_t aLineNumber, uint32_t aColumnNumber) + : css::Rule(aLineNumber, aColumnNumber) + { + } + BindingStyleRule(const BindingStyleRule& aCopy) + : css::Rule(aCopy) + { + } + virtual ~BindingStyleRule() {} + +public: + // This is pure virtual because we have no members, and are an abstract class + // to start with. The fact that we have to have this declaration at all is + // kinda dumb. :( + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) + const override MOZ_MUST_OVERRIDE = 0; + + // Likewise for this one. We have to override our superclass, but don't + // really need to do anything in this method. + virtual bool IsCCLeaf() const override MOZ_MUST_OVERRIDE = 0; + + // WebIDL API + // For GetSelectorText/SetSelectorText, we purposefully use a signature that + // matches the nsIDOMCSSStyleRule one for now, so subclasses can just + // implement both at once. The actual implementations must never return + // anything other than NS_OK; + NS_IMETHOD GetSelectorText(nsAString& aSelectorText) = 0; + NS_IMETHOD SetSelectorText(const nsAString& aSelectorText) = 0; + virtual nsICSSDeclaration* Style() = 0; + + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; +}; + +} // namespace mozilla + +#endif // mozilla_BindingStyleRule_h__ diff --git a/layout/style/CSSRuleList.h b/layout/style/CSSRuleList.h index 786cc1b884..60ceec0db9 100644 --- a/layout/style/CSSRuleList.h +++ b/layout/style/CSSRuleList.h @@ -7,6 +7,7 @@ #define mozilla_dom_CSSRuleList_h #include "mozilla/StyleSheetInlines.h" +#include "mozilla/css/Rule.h" #include "nsIDOMCSSRule.h" #include "nsIDOMCSSRuleList.h" #include "nsWrapperCache.h" @@ -45,13 +46,13 @@ public: } // WebIDL API - nsIDOMCSSRule* Item(uint32_t aIndex) + css::Rule* Item(uint32_t aIndex) { bool unused; return IndexedGetter(aIndex, unused); } - virtual nsIDOMCSSRule* IndexedGetter(uint32_t aIndex, bool& aFound) = 0; + virtual css::Rule* IndexedGetter(uint32_t aIndex, bool& aFound) = 0; virtual uint32_t Length() = 0; protected: diff --git a/layout/style/CSSStyleSheet.cpp b/layout/style/CSSStyleSheet.cpp index 5b8a9912fc..1307864c9d 100644 --- a/layout/style/CSSStyleSheet.cpp +++ b/layout/style/CSSStyleSheet.cpp @@ -61,7 +61,7 @@ public: virtual CSSStyleSheet* GetParentObject() override; - virtual nsIDOMCSSRule* + virtual css::Rule* IndexedGetter(uint32_t aIndex, bool& aFound) override; virtual uint32_t Length() override; @@ -101,7 +101,7 @@ CSSRuleListImpl::Length() return AssertedCast(mStyleSheet->StyleRuleCount()); } -nsIDOMCSSRule* +css::Rule* CSSRuleListImpl::IndexedGetter(uint32_t aIndex, bool& aFound) { aFound = false; @@ -112,7 +112,7 @@ CSSRuleListImpl::IndexedGetter(uint32_t aIndex, bool& aFound) css::Rule* rule = mStyleSheet->GetStyleRuleAt(aIndex); if (rule) { aFound = true; - return rule->GetDOMRule(); + return rule; } } @@ -1238,8 +1238,10 @@ CSSStyleSheet::TraverseInner(nsCycleCollectionTraversalCallback &cb) const nsCOMArray& rules = mInner->mOrderedRules; for (int32_t i = 0, count = rules.Count(); i < count; ++i) { - NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mOrderedRules[i]"); - cb.NoteXPCOMChild(rules[i]->GetExistingDOMRule()); + if (!rules[i]->IsCCLeaf()) { + NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mOrderedRules[i]"); + cb.NoteXPCOMChild(rules[i]); + } } } @@ -1646,10 +1648,10 @@ CSSStyleSheet::Media() return mMedia; } -nsIDOMCSSRule* +css::Rule* CSSStyleSheet::GetDOMOwnerRule() const { - return mOwnerRule ? mOwnerRule->GetDOMRule() : nullptr; + return mOwnerRule; } CSSRuleList* @@ -1812,11 +1814,6 @@ CSSStyleSheet::DeleteRuleInternal(uint32_t aIndex, ErrorResult& aRv) RefPtr rule = mInner->mOrderedRules.ObjectAt(aIndex); if (rule) { mInner->mOrderedRules.RemoveObjectAt(aIndex); - if (mDocument && mDocument->StyleSheetChangeEventsEnabled()) { - // Force creation of the DOM rule, so that it can be put on the - // StyleRuleRemoved event object. - rule->GetDOMRule(); - } rule->SetStyleSheet(nullptr); DidDirty(); diff --git a/layout/style/CSSStyleSheet.h b/layout/style/CSSStyleSheet.h index 69028dcdc8..640a05340f 100644 --- a/layout/style/CSSStyleSheet.h +++ b/layout/style/CSSStyleSheet.h @@ -212,7 +212,7 @@ public: // Can't be inline because we can't include ImportRule here. And can't be // called GetOwnerRule because that would be ambiguous with the ImportRule // version. - nsIDOMCSSRule* GetDOMOwnerRule() const final; + css::Rule* GetDOMOwnerRule() const final; void WillDirty(); void DidDirty(); diff --git a/layout/style/Declaration.h b/layout/style/Declaration.h index e7701e7380..f5b43439fd 100644 --- a/layout/style/Declaration.h +++ b/layout/style/Declaration.h @@ -96,6 +96,8 @@ public: NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_DECLARATION_IMPL_CID) + // If this ever becomes cycle-collected, please change the CC implementation + // for StyleRule to traverse it. NS_DECL_ISUPPORTS private: diff --git a/layout/style/GroupRule.h b/layout/style/GroupRule.h index ec781fae68..d153053ed4 100644 --- a/layout/style/GroupRule.h +++ b/layout/style/GroupRule.h @@ -12,6 +12,7 @@ #define mozilla_css_GroupRule_h__ #include "mozilla/Attributes.h" +#include "mozilla/ErrorResult.h" #include "mozilla/IncrementalClearCOMRuleArray.h" #include "mozilla/MemoryReporting.h" #include "mozilla/css/Rule.h" @@ -24,6 +25,10 @@ namespace mozilla { class CSSStyleSheet; +namespace dom { +class CSSRuleList; +} // namespace dom + namespace css { class GroupRuleRuleList; @@ -38,11 +43,10 @@ protected: virtual ~GroupRule(); public: - NS_DECL_CYCLE_COLLECTION_CLASS(GroupRule) - NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(GroupRule, Rule) + NS_DECL_ISUPPORTS_INHERITED + virtual bool IsCCLeaf() const override; - // implement part of Rule - DECL_STYLE_RULE_INHERIT_NO_DOMRULE #ifdef DEBUG virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override; #endif @@ -80,9 +84,15 @@ public: return true; } + // WebIDL API + dom::CSSRuleList* CssRules(); + uint32_t InsertRule(const nsAString& aRule, uint32_t aIndex, + ErrorResult& aRv); + void DeleteRule(uint32_t aIndex, ErrorResult& aRv); + protected: // to help implement nsIDOMCSSRule - void AppendRulesToCssText(nsAString& aCssText); + void AppendRulesToCssText(nsAString& aCssText) const; // to implement common methods on nsIDOMCSSMediaRule and // nsIDOMCSSMozDocumentRule @@ -95,6 +105,24 @@ protected: RefPtr mRuleCollection; // lazily constructed }; +// Implementation of WebIDL CSSConditionRule. +class ConditionRule : public GroupRule +{ +protected: + ConditionRule(uint32_t aLineNumber, uint32_t aColumnNumber); + ConditionRule(const ConditionRule& aCopy); + virtual ~ConditionRule(); + +public: + + // GetConditionText signature matches nsIDOMCSSConditionRule, so subclasses + // can implement this easily. The implementations should never return + // anything other than NS_OK. + NS_IMETHOD GetConditionText(nsAString& aConditionText) = 0; + virtual void SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) = 0; +}; + } // namespace css } // namespace mozilla diff --git a/layout/style/ImportRule.h b/layout/style/ImportRule.h index f0803ba9d0..077349d017 100644 --- a/layout/style/ImportRule.h +++ b/layout/style/ImportRule.h @@ -20,6 +20,7 @@ class nsString; namespace mozilla { class CSSStyleSheet; +class StyleSheet; namespace css { @@ -34,10 +35,9 @@ private: ImportRule(const ImportRule& aCopy); ~ImportRule(); public: - NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(ImportRule, mozilla::css::Rule) - NS_DECL_CYCLE_COLLECTING_ISUPPORTS - - DECL_STYLE_RULE_INHERIT + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ImportRule, Rule) + NS_DECL_ISUPPORTS_INHERITED + virtual bool IsCCLeaf() const override; #ifdef HAVE_CPP_AMBIGUITY_RESOLVING_USING using Rule::GetStyleSheet; // unhide since nsIDOMCSSImportRule has its own GetStyleSheet @@ -54,12 +54,18 @@ public: virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; // nsIDOMCSSImportRule interface NS_DECL_NSIDOMCSSIMPORTRULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // The XPCOM GetHref is fine, since it never fails. + nsMediaList* Media() const { return mMedia; } + StyleSheet* GetStyleSheet() const; + private: nsString mURLSpec; RefPtr mMedia; diff --git a/layout/style/NameSpaceRule.h b/layout/style/NameSpaceRule.h index 92d910cf5d..06848b0bb1 100644 --- a/layout/style/NameSpaceRule.h +++ b/layout/style/NameSpaceRule.h @@ -24,8 +24,7 @@ class nsIAtom; namespace mozilla { namespace css { -class NameSpaceRule final : public Rule, - public nsIDOMCSSRule +class NameSpaceRule final : public Rule { public: NameSpaceRule(nsIAtom* aPrefix, const nsString& aURLSpec, @@ -37,25 +36,28 @@ private: public: NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_NAMESPACE_RULE_IMPL_CID) - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS_INHERITED + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed Clone() const override; nsIAtom* GetPrefix() const { return mPrefix; } void GetURLSpec(nsString& aURLSpec) const { aURLSpec = mURLSpec; } + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override MOZ_MUST_OVERRIDE; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; private: nsCOMPtr mPrefix; diff --git a/layout/style/Rule.h b/layout/style/Rule.h index 7abe71174e..9586edffd4 100644 --- a/layout/style/Rule.h +++ b/layout/style/Rule.h @@ -12,6 +12,7 @@ #include "mozilla/MemoryReporting.h" #include "nsISupports.h" #include "nsIDOMCSSRule.h" +#include "nsWrapperCache.h" class nsIDocument; struct nsRuleData; @@ -22,15 +23,9 @@ namespace mozilla { namespace css { class GroupRule; -#define DECL_STYLE_RULE_INHERIT_NO_DOMRULE \ - /* nothing */ - -#define DECL_STYLE_RULE_INHERIT \ - DECL_STYLE_RULE_INHERIT_NO_DOMRULE \ - virtual nsIDOMCSSRule* GetDOMRule() override; \ - virtual nsIDOMCSSRule* GetExistingDOMRule() override; - -class Rule : public nsISupports { +class Rule : public nsIDOMCSSRule + , public nsWrapperCache +{ protected: Rule(uint32_t aLineNumber, uint32_t aColumnNumber) : mSheet(nullptr), @@ -51,6 +46,14 @@ protected: virtual ~Rule() {} 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; + + // nsIDOMCSSRule interface + NS_DECL_NSIDOMCSSRULE #ifdef DEBUG virtual void List(FILE* out = stdout, int32_t aIndent = 0) const = 0; @@ -106,24 +109,24 @@ public: */ virtual already_AddRefed Clone() const = 0; - // Note that this returns null for inline style rules since they aren't - // supposed to have a DOM rule representation (and our code wouldn't work). - virtual nsIDOMCSSRule* GetDOMRule() = 0; - - // Like GetDOMRule(), but won't create one if we don't have one yet - virtual nsIDOMCSSRule* GetExistingDOMRule() = 0; - - // to implement methods on nsIDOMCSSRule - nsresult GetParentRule(nsIDOMCSSRule** aParentRule); - nsresult GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet); - Rule* GetCSSRule(); - // This is pure virtual because all of Rule's data members are non-owning and // thus measured elsewhere. virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_MUST_OVERRIDE = 0; + // WebIDL interface, aka helpers for nsIDOMCSSRule implementation. + virtual uint16_t Type() const = 0; + virtual void GetCssTextImpl(nsAString& aCssText) const = 0; + // XPCOM GetCssText is OK, since it never throws. + // XPCOM SetCssText is OK, since it never throws. + Rule* GetParentRule() const; + StyleSheet* GetParentStyleSheet() const { return GetStyleSheet(); } + nsIDocument* GetParentObject() const { return GetDocument(); } + protected: + // True if we're known-live for cycle collection purposes. + bool IsKnownLive() const; + // This is sometimes null (e.g., for style attributes). CSSStyleSheet* mSheet; // When the parent GroupRule is destroyed, it will call SetParentRule(nullptr) diff --git a/layout/style/StyleRule.cpp b/layout/style/StyleRule.cpp index 5c3ec354d5..97a17d2871 100644 --- a/layout/style/StyleRule.cpp +++ b/layout/style/StyleRule.cpp @@ -15,11 +15,11 @@ #include "mozilla/MemoryReporting.h" #include "mozilla/css/GroupRule.h" #include "mozilla/css/Declaration.h" +#include "mozilla/dom/CSSStyleRuleBinding.h" #include "nsIDocument.h" #include "nsIAtom.h" #include "nsString.h" #include "nsStyleUtil.h" -#include "nsICSSStyleRuleDOMWrapper.h" #include "nsDOMCSSDeclaration.h" #include "nsNameSpaceManager.h" #include "nsXMLNameSpaceMap.h" @@ -27,7 +27,6 @@ #include "nsCSSPseudoClasses.h" #include "nsCSSAnonBoxes.h" #include "nsTArray.h" -#include "nsDOMClassInfoID.h" #include "nsContentUtils.h" #include "nsError.h" #include "mozAutoDocUpdate.h" @@ -1096,30 +1095,26 @@ nsCSSSelectorList::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) cons // -------------------------------------------------------- -namespace mozilla { -namespace css { -class DOMCSSStyleRule; -} // namespace css -} // namespace mozilla - class DOMCSSDeclarationImpl : public nsDOMCSSDeclaration { protected: + // Needs to be protected so we can use NS_IMPL_ADDREF_USING_AGGREGATOR. virtual ~DOMCSSDeclarationImpl(void); + // But we need to allow UniquePtr to delete us. + friend class mozilla::DefaultDelete; + public: explicit DOMCSSDeclarationImpl(css::StyleRule *aRule); NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) override; - void DropReference(void); virtual css::Declaration* GetCSSDeclaration(Operation aOperation) override; virtual nsresult SetCSSDeclaration(css::Declaration* aDecl) override; virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) override; virtual nsIDocument* DocToUpdate() override; - // Override |AddRef| and |Release| for being a member of - // |DOMCSSStyleRule|. Also, we need to forward QI for cycle - // collection things to DOMCSSStyleRule. + // Override |AddRef| and |Release| for being owned by StyleRule. Also, we + // need to forward QI for cycle collection things to StyleRule. NS_DECL_ISUPPORTS_INHERITED virtual nsINode *GetParentObject() override @@ -1137,55 +1132,12 @@ public: return document ? document->GetDocGroup() : nullptr; } - friend class css::DOMCSSStyleRule; - protected: - // This reference is not reference-counted. The rule object tells us - // when it's about to go away. + // This reference is not reference-counted. The rule object owns us and we go + // away when it does. css::StyleRule *mRule; - - inline css::DOMCSSStyleRule* DomRule(); - -private: - // NOT TO BE IMPLEMENTED - // This object cannot be allocated on its own. It must be a member of - // DOMCSSStyleRule. - void* operator new(size_t size) CPP_THROW_NEW; }; -namespace mozilla { -namespace css { - -class DOMCSSStyleRule : public nsICSSStyleRuleDOMWrapper -{ -public: - explicit DOMCSSStyleRule(StyleRule *aRule); - - NS_DECL_CYCLE_COLLECTING_ISUPPORTS - NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMCSSStyleRule) - NS_DECL_NSIDOMCSSRULE - NS_DECL_NSIDOMCSSSTYLERULE - - // nsICSSStyleRuleDOMWrapper - NS_IMETHOD GetCSSStyleRule(StyleRule **aResult) override; - - DOMCSSDeclarationImpl* DOMDeclaration() { return &mDOMDeclaration; } - - friend class ::DOMCSSDeclarationImpl; - -protected: - virtual ~DOMCSSStyleRule(); - - DOMCSSDeclarationImpl mDOMDeclaration; - - StyleRule* Rule() { - return mDOMDeclaration.mRule; - } -}; - -} // namespace css -} // namespace mozilla - DOMCSSDeclarationImpl::DOMCSSDeclarationImpl(css::StyleRule *aRule) : mRule(aRule) { @@ -1194,52 +1146,33 @@ DOMCSSDeclarationImpl::DOMCSSDeclarationImpl(css::StyleRule *aRule) DOMCSSDeclarationImpl::~DOMCSSDeclarationImpl(void) { - NS_ASSERTION(!mRule, "DropReference not called."); - MOZ_COUNT_DTOR(DOMCSSDeclarationImpl); } -inline css::DOMCSSStyleRule* DOMCSSDeclarationImpl::DomRule() -{ - return reinterpret_cast - (reinterpret_cast(this) - - offsetof(css::DOMCSSStyleRule, mDOMDeclaration)); -} - -NS_IMPL_ADDREF_USING_AGGREGATOR(DOMCSSDeclarationImpl, DomRule()) -NS_IMPL_RELEASE_USING_AGGREGATOR(DOMCSSDeclarationImpl, DomRule()) +NS_IMPL_ADDREF_USING_AGGREGATOR(DOMCSSDeclarationImpl, mRule) +NS_IMPL_RELEASE_USING_AGGREGATOR(DOMCSSDeclarationImpl, mRule) NS_INTERFACE_MAP_BEGIN(DOMCSSDeclarationImpl) NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY - // We forward the cycle collection interfaces to DomRule(), which is - // never null (in fact, we're part of that object!) + // We forward the cycle collection interfaces to mRule, which is + // never null. if (aIID.Equals(NS_GET_IID(nsCycleCollectionISupports)) || aIID.Equals(NS_GET_IID(nsXPCOMCycleCollectionParticipant))) { - return DomRule()->QueryInterface(aIID, aInstancePtr); + return mRule->QueryInterface(aIID, aInstancePtr); } else NS_IMPL_QUERY_TAIL_INHERITING(nsDOMCSSDeclaration) -void -DOMCSSDeclarationImpl::DropReference(void) -{ - mRule = nullptr; -} - css::Declaration* DOMCSSDeclarationImpl::GetCSSDeclaration(Operation aOperation) { - if (mRule) { - if (aOperation != eOperation_Read) { - RefPtr sheet = mRule->GetStyleSheet(); - if (sheet) { - sheet->WillDirty(); - } + if (aOperation != eOperation_Read) { + RefPtr sheet = mRule->GetStyleSheet(); + if (sheet) { + sheet->WillDirty(); } - return mRule->GetDeclaration(); - } else { - return nullptr; } + return mRule->GetDeclaration(); } void @@ -1253,12 +1186,7 @@ DOMCSSDeclarationImpl::GetParentRule(nsIDOMCSSRule **aParent) { NS_ENSURE_ARG_POINTER(aParent); - if (!mRule) { - *aParent = nullptr; - return NS_OK; - } - - NS_IF_ADDREF(*aParent = mRule->GetDOMRule()); + NS_IF_ADDREF(*aParent = mRule); return NS_OK; } @@ -1294,153 +1222,48 @@ DOMCSSDeclarationImpl::DocToUpdate() return nullptr; } -namespace mozilla { -namespace css { - -DOMCSSStyleRule::DOMCSSStyleRule(StyleRule* aRule) - : mDOMDeclaration(aRule) -{ -} - -DOMCSSStyleRule::~DOMCSSStyleRule() -{ -} - -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMCSSStyleRule) - NS_INTERFACE_MAP_ENTRY(nsICSSStyleRuleDOMWrapper) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSStyleRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY(nsISupports) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSStyleRule) -NS_INTERFACE_MAP_END - -NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMCSSStyleRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMCSSStyleRule) - -NS_IMPL_CYCLE_COLLECTION_CLASS(DOMCSSStyleRule) - -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(DOMCSSStyleRule) - // 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->DOMDeclaration()->TraceWrapper(aCallbacks, aClosure); -NS_IMPL_CYCLE_COLLECTION_TRACE_END - -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMCSSStyleRule) - // 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->DOMDeclaration()->ReleaseWrapper(static_cast(p)); -NS_IMPL_CYCLE_COLLECTION_UNLINK_END - -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(DOMCSSStyleRule) -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END - -NS_IMETHODIMP -DOMCSSStyleRule::GetType(uint16_t* aType) -{ - *aType = nsIDOMCSSRule::STYLE_RULE; - - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetCssText(nsAString& aCssText) -{ - if (!Rule()) { - aCssText.Truncate(); - } else { - Rule()->GetCssText(aCssText); - } - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::SetCssText(const nsAString& aCssText) -{ - if (Rule()) { - Rule()->SetCssText(aCssText); - } - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - if (!Rule()) { - *aSheet = nullptr; - return NS_OK; - } - return Rule()->GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - if (!Rule()) { - *aParentRule = nullptr; - return NS_OK; - } - return Rule()->GetParentRule(aParentRule); -} - -css::Rule* -DOMCSSStyleRule::GetCSSRule() -{ - return Rule(); -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetSelectorText(nsAString& aSelectorText) -{ - if (!Rule()) { - aSelectorText.Truncate(); - } else { - Rule()->GetSelectorText(aSelectorText); - } - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::SetSelectorText(const nsAString& aSelectorText) -{ - if (Rule()) { - Rule()->SetSelectorText(aSelectorText); - } - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetStyle(nsIDOMCSSStyleDeclaration** aStyle) -{ - *aStyle = &mDOMDeclaration; - NS_ADDREF(*aStyle); - return NS_OK; -} - -NS_IMETHODIMP -DOMCSSStyleRule::GetCSSStyleRule(StyleRule **aResult) -{ - *aResult = Rule(); - NS_IF_ADDREF(*aResult); - return NS_OK; -} - -} // namespace css -} // namespace mozilla - // -- StyleRule ------------------------------------ namespace mozilla { namespace css { +uint16_t +StyleRule::Type() const +{ + return nsIDOMCSSRule::STYLE_RULE; +} + +NS_IMETHODIMP +StyleRule::GetStyle(nsIDOMCSSStyleDeclaration** aStyle) +{ + NS_ADDREF(*aStyle = Style()); + return NS_OK; +} + +nsICSSDeclaration* +StyleRule::Style() +{ + if (!mDOMDeclaration) { + mDOMDeclaration.reset(new DOMCSSDeclarationImpl(this)); + } + return mDOMDeclaration.get(); +} + +NS_IMETHODIMP +StyleRule::GetCSSStyleRule(StyleRule **aResult) +{ + *aResult = this; + NS_ADDREF(*aResult); + return NS_OK; +} + StyleRule::StyleRule(nsCSSSelectorList* aSelector, Declaration* aDeclaration, uint32_t aLineNumber, uint32_t aColumnNumber) - : Rule(aLineNumber, aColumnNumber), - mSelector(aSelector), - mDeclaration(aDeclaration) + : BindingStyleRule(aLineNumber, aColumnNumber) + , mSelector(aSelector) + , mDeclaration(aDeclaration) { NS_PRECONDITION(aDeclaration, "must have a declaration"); @@ -1449,9 +1272,9 @@ StyleRule::StyleRule(nsCSSSelectorList* aSelector, // for |Clone| StyleRule::StyleRule(const StyleRule& aCopy) - : Rule(aCopy), - mSelector(aCopy.mSelector ? aCopy.mSelector->Clone() : nullptr), - mDeclaration(new Declaration(*aCopy.mDeclaration)) + : BindingStyleRule(aCopy) + , mSelector(aCopy.mSelector ? aCopy.mSelector->Clone() : nullptr) + , mDeclaration(new Declaration(*aCopy.mDeclaration)) { mDeclaration->SetOwningRule(this); // rest is constructed lazily on existing data @@ -1460,28 +1283,66 @@ StyleRule::StyleRule(const StyleRule& aCopy) StyleRule::~StyleRule() { delete mSelector; - if (mDOMRule) { - mDOMRule->DOMDeclaration()->DropReference(); - } + DropReferences(); +} +void +StyleRule::DropReferences() +{ if (mDeclaration) { mDeclaration->SetOwningRule(nullptr); } } // QueryInterface implementation for StyleRule -NS_INTERFACE_MAP_BEGIN(StyleRule) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(StyleRule) if (aIID.Equals(NS_GET_IID(mozilla::css::StyleRule))) { *aInstancePtr = this; NS_ADDREF_THIS(); return NS_OK; } else - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) -NS_INTERFACE_MAP_END + NS_INTERFACE_MAP_ENTRY(nsICSSStyleRuleDOMWrapper) + NS_INTERFACE_MAP_ENTRY(nsIDOMCSSStyleRule) +NS_INTERFACE_MAP_END_INHERITING(Rule) -NS_IMPL_ADDREF(StyleRule) -NS_IMPL_RELEASE(StyleRule) +NS_IMPL_ADDREF_INHERITED(StyleRule, Rule) +NS_IMPL_RELEASE_INHERITED(StyleRule, Rule) + +NS_IMPL_CYCLE_COLLECTION_CLASS(StyleRule) + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(StyleRule, 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. + if (tmp->mDOMDeclaration) { + tmp->mDOMDeclaration->TraceWrapper(aCallbacks, aClosure); + } +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(StyleRule, Rule) + // 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. + if (tmp->mDOMDeclaration) { + tmp->mDOMDeclaration->ReleaseWrapper(static_cast(p)); + } + tmp->DropReferences(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(StyleRule, Rule) + // Keep this in sync with IsCCLeaf. +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +bool +StyleRule::IsCCLeaf() const +{ + if (!Rule::IsCCLeaf()) { + return false; + } + + return !mDOMDeclaration || !mDOMDeclaration->PreservingWrapper(); +} /* virtual */ int32_t StyleRule::GetType() const @@ -1496,27 +1357,6 @@ StyleRule::Clone() const return clone.forget(); } -/* virtual */ nsIDOMCSSRule* -StyleRule::GetDOMRule() -{ - if (!mDOMRule) { - if (!GetStyleSheet()) { - // Inline style rules aren't supposed to have a DOM rule object, only - // a declaration. But if we do have one already, from a style sheet - // rule that used to be in a document, we still want to return it. - return nullptr; - } - mDOMRule = new DOMCSSStyleRule(this); - } - return mDOMRule; -} - -/* virtual */ nsIDOMCSSRule* -StyleRule::GetExistingDOMRule() -{ - return mDOMRule; -} - void StyleRule::SetDeclaration(Declaration* aDecl) { @@ -1572,7 +1412,7 @@ StyleRule::List(FILE* out, int32_t aIndent) const #endif void -StyleRule::GetCssText(nsAString& aCssText) +StyleRule::GetCssTextImpl(nsAString& aCssText) const { if (mSelector) { mSelector->ToString(aCssText, GetStyleSheet()); @@ -1590,22 +1430,17 @@ StyleRule::GetCssText(nsAString& aCssText) aCssText.Append(char16_t('}')); } -void -StyleRule::SetCssText(const nsAString& aCssText) -{ - // XXX TBI - need to re-parse rule & declaration -} - -void +NS_IMETHODIMP StyleRule::GetSelectorText(nsAString& aSelectorText) { if (mSelector) mSelector->ToString(aSelectorText, GetStyleSheet()); else aSelectorText.Truncate(); + return NS_OK; } -void +NS_IMETHODIMP StyleRule::SetSelectorText(const nsAString& aSelectorText) { CSSStyleSheet* sheet = GetStyleSheet(); @@ -1632,7 +1467,7 @@ StyleRule::SetSelectorText(const nsAString& aSelectorText) aSelectorText, sheet->GetSheetURI(), 0, &selectorList); if (NS_FAILED(result)) { // Ignore parsing errors and continue to use the previous value. - return; + return NS_OK; } // Replace selector. @@ -1645,6 +1480,8 @@ StyleRule::SetSelectorText(const nsAString& aSelectorText) mozAutoDocUpdate updateBatch(doc, UPDATE_STYLE, true); doc->StyleRuleChanged(sheet, this); } + + return NS_OK; } /* virtual */ size_t @@ -1661,6 +1498,5 @@ StyleRule::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const return n; } - } // namespace css } // namespace mozilla diff --git a/layout/style/StyleRule.h b/layout/style/StyleRule.h index f2af2717b5..ba10542c78 100644 --- a/layout/style/StyleRule.h +++ b/layout/style/StyleRule.h @@ -13,12 +13,14 @@ #include "mozilla/Attributes.h" #include "mozilla/MemoryReporting.h" -#include "mozilla/css/Rule.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/BindingStyleRule.h" #include "nsString.h" #include "nsCOMPtr.h" #include "nsCSSPseudoElements.h" #include "nsIStyleRule.h" +#include "nsICSSStyleRuleDOMWrapper.h" class nsIAtom; struct nsCSSSelectorList; @@ -316,13 +318,15 @@ private: { 0x464bab7a, 0x2fce, 0x4f30, \ { 0xab, 0x44, 0xb7, 0xa5, 0xf3, 0xaa, 0xe5, 0x7d } } +class DOMCSSDeclarationImpl; + namespace mozilla { namespace css { class Declaration; -class DOMCSSStyleRule; -class StyleRule final : public Rule +class StyleRule final : public BindingStyleRule + , public nsICSSStyleRuleDOMWrapper { public: StyleRule(nsCSSSelectorList* aSelector, @@ -334,7 +338,19 @@ private: public: NS_DECLARE_STATIC_IID_ACCESSOR(NS_CSS_STYLE_RULE_IMPL_CID) - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(StyleRule, Rule) + virtual bool IsCCLeaf() const override; + + NS_DECL_NSIDOMCSSSTYLERULE + + // nsICSSStyleRuleDOMWrapper + NS_IMETHOD GetCSSStyleRule(StyleRule **aResult) override; + + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + virtual nsICSSDeclaration* Style() override; // null for style attribute nsCSSSelectorList* Selector() { return mSelector; } @@ -343,20 +359,11 @@ public: void SetDeclaration(Declaration* aDecl); - // hooks for DOM rule - void GetCssText(nsAString& aCssText); - void SetCssText(const nsAString& aCssText); - void GetSelectorText(nsAString& aSelectorText); - void SetSelectorText(const nsAString& aSelectorText); - virtual int32_t GetType() const override; + using Rule::GetType; virtual already_AddRefed Clone() const override; - virtual nsIDOMCSSRule* GetDOMRule() override; - - virtual nsIDOMCSSRule* GetExistingDOMRule() override; - #ifdef DEBUG virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override; #endif @@ -366,10 +373,16 @@ public: private: ~StyleRule(); + // Drop our references to mDeclaration and mRule, and let them know we're + // doing that. + void DropReferences(); + private: nsCSSSelectorList* mSelector; // null for style attribute RefPtr mDeclaration; - RefPtr mDOMRule; + + // We own it, and it aggregates its refcount with us. + UniquePtr mDOMDeclaration; private: StyleRule& operator=(const StyleRule& aCopy) = delete; diff --git a/layout/style/StyleSheet.h b/layout/style/StyleSheet.h index bbd455a02b..fd1e9b3652 100644 --- a/layout/style/StyleSheet.h +++ b/layout/style/StyleSheet.h @@ -29,6 +29,10 @@ class CSSRuleList; class SRIMetadata; } // namespace dom +namespace css { +class Rule; +} + /** * Superclass for CSSStyleSheet. */ @@ -145,7 +149,7 @@ public: // The XPCOM SetDisabled is fine for WebIDL. // WebIDL CSSStyleSheet API - virtual nsIDOMCSSRule* GetDOMOwnerRule() const = 0; + virtual css::Rule* GetDOMOwnerRule() const = 0; dom::CSSRuleList* GetCssRules(nsIPrincipal& aSubjectPrincipal, ErrorResult& aRv); uint32_t InsertRule(const nsAString& aRule, uint32_t aIndex, diff --git a/layout/style/moz.build b/layout/style/moz.build index 7239526aa8..1212a92d10 100644 --- a/layout/style/moz.build +++ b/layout/style/moz.build @@ -74,6 +74,7 @@ EXPORTS += [ EXPORTS.mozilla += [ 'AnimationCollection.h', + 'BindingStyleRule.h', 'CSSEnabledState.h', 'CSSStyleSheet.h', 'CSSVariableDeclarations.h', @@ -177,10 +178,18 @@ UNIFIED_SOURCES += [ 'SVGAttrAnimationRuleProcessor.cpp', ] -# nsCSSRuleProcessor.cpp needs to be built separately because it uses plarena.h. -# nsLayoutStylesheetCache.cpp needs to be built separately because it uses +# - BindingStyleRule.cpp doesn't necessarily need to be built separately, +# however, it may shift unified build boundaries, causing +# the Unified CPP containing it to include nsStyleCoord.cpp, which +# includes, via nsStyleCoord.h, , which ends up including +# , which fails in much the way described in +# . +# - nsCSSRuleProcessor.cpp needs to be built separately because it uses +# plarena.h. +# - nsLayoutStylesheetCache.cpp needs to be built separately because it uses # nsExceptionHandler.h, which includes windows.h. SOURCES += [ + 'BindingStyleRule.cpp', 'nsCSSRuleProcessor.cpp', 'nsLayoutStylesheetCache.cpp', ] diff --git a/layout/style/nsCSSRules.cpp b/layout/style/nsCSSRules.cpp index 1642516979..08d2deb7f0 100644 --- a/layout/style/nsCSSRules.cpp +++ b/layout/style/nsCSSRules.cpp @@ -33,28 +33,84 @@ #include "nsCSSParser.h" #include "nsDOMClassInfoID.h" #include "mozilla/dom/CSSStyleDeclarationBinding.h" +#include "mozilla/dom/CSSNamespaceRuleBinding.h" +#include "mozilla/dom/CSSImportRuleBinding.h" +#include "mozilla/dom/CSSMediaRuleBinding.h" +#include "mozilla/dom/CSSSupportsRuleBinding.h" +#include "mozilla/dom/CSSMozDocumentRuleBinding.h" +#include "mozilla/dom/CSSPageRuleBinding.h" +#include "mozilla/dom/CSSFontFaceRuleBinding.h" +#include "mozilla/dom/CSSFontFeatureValuesRuleBinding.h" +#include "mozilla/dom/CSSKeyframeRuleBinding.h" +#include "mozilla/dom/CSSKeyframesRuleBinding.h" +#include "mozilla/dom/CSSCounterStyleRuleBinding.h" #include "StyleRule.h" #include "nsFont.h" #include "nsIURI.h" #include "mozAutoDocUpdate.h" +#include "nsCCUncollectableMarker.h" +#include "nsWrapperCacheInlines.h" using namespace mozilla; using namespace mozilla::dom; -#define IMPL_STYLE_RULE_INHERIT_GET_DOM_RULE_WEAK(class_, super_) \ - /* virtual */ nsIDOMCSSRule* class_::GetDOMRule() \ - { return this; } \ - /* virtual */ nsIDOMCSSRule* class_::GetExistingDOMRule() \ - { return this; } - -#define IMPL_STYLE_RULE_INHERIT(class_, super_) \ -IMPL_STYLE_RULE_INHERIT_GET_DOM_RULE_WEAK(class_, super_) - // base class for all rule types in a CSS style sheet namespace mozilla { namespace css { +NS_IMPL_CYCLE_COLLECTING_ADDREF(Rule) +NS_IMPL_CYCLE_COLLECTING_RELEASE(Rule) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Rule) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(Rule) + +bool +Rule::IsCCLeaf() const +{ + return !PreservingWrapper(); +} + +bool +Rule::IsKnownLive() const +{ + if (IsBlack()) { + return true; + } + + StyleSheet* sheet = GetStyleSheet(); + if (!sheet) { + return false; + } + + if (!sheet->IsOwnedByDocument()) { + return false; + } + + return nsCCUncollectableMarker::InGeneration( + sheet->GetAssociatedDocument()->GetMarkedCCGeneration()); +} + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(Rule) + return tmp->IsCCLeaf() || tmp->IsKnownLive(); +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(Rule) + // Please see documentation for nsCycleCollectionParticipant::CanSkip* for why + // we need to check HasNothingToTrace here but not in the other two CanSkip + // methods. + return tmp->IsCCLeaf() || (tmp->IsKnownLive() && tmp->HasNothingToTrace(tmp)); +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END + +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(Rule) + return tmp->IsCCLeaf() || tmp->IsKnownLive(); +NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END + /* virtual */ void Rule::SetStyleSheet(CSSStyleSheet* aSheet) { @@ -64,18 +120,14 @@ Rule::SetStyleSheet(CSSStyleSheet* aSheet) mSheet = aSheet; } -nsresult +NS_IMETHODIMP Rule::GetParentRule(nsIDOMCSSRule** aParentRule) { - if (mParentRule) { - NS_IF_ADDREF(*aParentRule = mParentRule->GetDOMRule()); - } else { - *aParentRule = nullptr; - } + NS_IF_ADDREF(*aParentRule = mParentRule); return NS_OK; } -nsresult +NS_IMETHODIMP Rule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) { NS_ENSURE_ARG_POINTER(aSheet); @@ -84,12 +136,40 @@ Rule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) return NS_OK; } -css::Rule* +/* virtual */ css::Rule* Rule::GetCSSRule() { return this; } +NS_IMETHODIMP +Rule::GetType(uint16_t* aType) +{ + *aType = Type(); + return NS_OK; +} + +NS_IMETHODIMP +Rule::SetCssText(const nsAString& aCssText) +{ + // We used to throw for some rule types, but not all. Specifically, we did + // not throw for StyleRule. Let's just always not throw. + return NS_OK; +} + +NS_IMETHODIMP +Rule::GetCssText(nsAString& aCssText) +{ + GetCssTextImpl(aCssText); + return NS_OK; +} + +Rule* +Rule::GetParentRule() const +{ + return mParentRule; +} + // ------------------------------- // Style Rule List for group rules // @@ -101,7 +181,7 @@ public: virtual CSSStyleSheet* GetParentObject() override; - virtual nsIDOMCSSRule* + virtual Rule* IndexedGetter(uint32_t aIndex, bool& aFound) override; virtual uint32_t Length() override; @@ -146,7 +226,7 @@ GroupRuleRuleList::Length() return AssertedCast(mGroupRule->StyleRuleCount()); } -nsIDOMCSSRule* +Rule* GroupRuleRuleList::IndexedGetter(uint32_t aIndex, bool& aFound) { aFound = false; @@ -155,7 +235,7 @@ GroupRuleRuleList::IndexedGetter(uint32_t aIndex, bool& aFound) RefPtr rule = mGroupRule->GetStyleRuleAt(aIndex); if (rule) { aFound = true; - return rule->GetDOMRule(); + return rule; } } @@ -172,6 +252,7 @@ ImportRule::ImportRule(nsMediaList* aMedia, const nsString& aURLSpec, , mURLSpec(aURLSpec) , mMedia(aMedia) { + MOZ_ASSERT(aMedia); // XXXbz This is really silly.... the mMedia here will be replaced // with itself if we manage to load a sheet. Which should really // never fail nowadays, in sane cases. @@ -199,18 +280,20 @@ ImportRule::~ImportRule() } } -NS_IMPL_CYCLE_COLLECTING_ADDREF(ImportRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(ImportRule) +NS_IMPL_ADDREF_INHERITED(ImportRule, Rule) +NS_IMPL_RELEASE_INHERITED(ImportRule, Rule) + +bool +ImportRule::IsCCLeaf() const +{ + // We're not a leaf. + return false; +} // QueryInterface implementation for ImportRule -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ImportRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ImportRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSImportRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSImportRule) -NS_INTERFACE_MAP_END - -IMPL_STYLE_RULE_INHERIT(ImportRule, Rule) +NS_INTERFACE_MAP_END_INHERITING(Rule) NS_IMPL_CYCLE_COLLECTION_CLASS(ImportRule) @@ -275,16 +358,14 @@ ImportRule::SetSheet(CSSStyleSheet* aSheet) mMedia = mChildSheet->Media(); } -NS_IMETHODIMP -ImportRule::GetType(uint16_t* aType) +uint16_t +ImportRule::Type() const { - NS_ENSURE_ARG_POINTER(aType); - *aType = nsIDOMCSSRule::IMPORT_RULE; - return NS_OK; + return nsIDOMCSSRule::IMPORT_RULE; } -NS_IMETHODIMP -ImportRule::GetCssText(nsAString& aCssText) +void +ImportRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@import url("); nsStyleUtil::AppendEscapedCSSString(mURLSpec, aCssText); @@ -298,31 +379,12 @@ ImportRule::GetCssText(nsAString& aCssText) } } aCssText.Append(';'); - return NS_OK; } -NS_IMETHODIMP -ImportRule::SetCssText(const nsAString& aCssText) +StyleSheet* +ImportRule::GetStyleSheet() const { - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -ImportRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -ImportRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -ImportRule::GetCSSRule() -{ - return Rule::GetCSSRule(); + return mChildSheet; } NS_IMETHODIMP @@ -337,7 +399,7 @@ ImportRule::GetMedia(nsIDOMMediaList * *aMedia) { NS_ENSURE_ARG_POINTER(aMedia); - NS_IF_ADDREF(*aMedia = mMedia); + NS_ADDREF(*aMedia = mMedia); return NS_OK; } @@ -364,6 +426,13 @@ ImportRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const // - mChildSheet, because it is measured via CSSStyleSheetInner::mSheets } +/* virtual */ JSObject* +ImportRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSImportRuleBinding::Wrap(aCx, this, aGivenProto); +} + GroupRule::GroupRule(uint32_t aLineNumber, uint32_t aColumnNumber) : Rule(aLineNumber, aColumnNumber) { @@ -393,11 +462,18 @@ GroupRule::~GroupRule() } } -NS_IMPL_CYCLE_COLLECTING_ADDREF(GroupRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(GroupRule) +NS_IMPL_ADDREF_INHERITED(GroupRule, Rule) +NS_IMPL_RELEASE_INHERITED(GroupRule, Rule) -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(GroupRule) -NS_INTERFACE_MAP_END +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(GroupRule) +NS_INTERFACE_MAP_END_INHERITING(Rule) + +bool +GroupRule::IsCCLeaf() const +{ + // Let's not worry for now about sorting out whether we're a leaf or not. + return false; +} static bool SetStyleSheetReference(Rule* aRule, void* aSheet) @@ -409,7 +485,7 @@ SetStyleSheetReference(Rule* aRule, void* aSheet) NS_IMPL_CYCLE_COLLECTION_CLASS(GroupRule) -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(GroupRule) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(GroupRule, Rule) tmp->mRules.EnumerateForwards(SetParentRuleReference, nullptr); // If tmp does not have a stylesheet, neither do its descendants. In that // case, don't try to null out their stylesheet, to avoid O(N^2) behavior in @@ -427,11 +503,13 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(GroupRule) } NS_IMPL_CYCLE_COLLECTION_UNLINK_END -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(GroupRule) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(GroupRule, Rule) const nsCOMArray& rules = tmp->mRules; for (int32_t i = 0, count = rules.Count(); i < count; ++i) { - NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mRules[i]"); - cb.NoteXPCOMChild(rules[i]->GetExistingDOMRule()); + if (!rules[i]->IsCCLeaf()) { + NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mRules[i]"); + cb.NoteXPCOMChild(rules[i]); + } } NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRuleCollection) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END @@ -513,21 +591,18 @@ GroupRule::InsertStyleRuleAt(uint32_t aIndex, Rule* aRule) } void -GroupRule::AppendRulesToCssText(nsAString& aCssText) +GroupRule::AppendRulesToCssText(nsAString& aCssText) const { aCssText.AppendLiteral(" {\n"); // get all the rules for (int32_t index = 0, count = mRules.Count(); index < count; ++index) { Rule* rule = mRules.ObjectAt(index); - nsIDOMCSSRule* domRule = rule->GetDOMRule(); - if (domRule) { - nsAutoString cssText; - domRule->GetCssText(cssText); - aCssText.AppendLiteral(" "); - aCssText.Append(cssText); - aCssText.Append('\n'); - } + nsAutoString cssText; + rule->GetCssText(cssText); + aCssText.AppendLiteral(" "); + aCssText.Append(cssText); + aCssText.Append('\n'); } aCssText.Append('}'); @@ -536,43 +611,85 @@ GroupRule::AppendRulesToCssText(nsAString& aCssText) // nsIDOMCSSMediaRule or nsIDOMCSSMozDocumentRule methods nsresult GroupRule::GetCssRules(nsIDOMCSSRuleList* *aRuleList) +{ + NS_ADDREF(*aRuleList = CssRules()); + return NS_OK; +} + +CSSRuleList* +GroupRule::CssRules() { if (!mRuleCollection) { mRuleCollection = new css::GroupRuleRuleList(this); } - NS_ADDREF(*aRuleList = mRuleCollection); - return NS_OK; + return mRuleCollection; } nsresult GroupRule::InsertRule(const nsAString & aRule, uint32_t aIndex, uint32_t* _retval) +{ + ErrorResult rv; + *_retval = InsertRule(aRule, aIndex, rv); + return rv.StealNSResult(); +} + +uint32_t +GroupRule::InsertRule(const nsAString& aRule, uint32_t aIndex, ErrorResult& aRv) { CSSStyleSheet* sheet = GetStyleSheet(); - NS_ENSURE_TRUE(sheet, NS_ERROR_FAILURE); - - if (aIndex > uint32_t(mRules.Count())) - return NS_ERROR_DOM_INDEX_SIZE_ERR; + if (NS_WARN_IF(!sheet)) { + aRv.Throw(NS_ERROR_FAILURE); + return 0; + } + + if (aIndex > uint32_t(mRules.Count())) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return 0; + } NS_ASSERTION(uint32_t(mRules.Count()) <= INT32_MAX, "Too many style rules!"); - return sheet->InsertRuleIntoGroup(aRule, this, aIndex, _retval); + uint32_t retval; + nsresult rv = + sheet->InsertRuleIntoGroup(aRule, this, aIndex, &retval); + if (NS_FAILED(rv)) { + aRv.Throw(rv); + return 0; + } + return retval; } nsresult GroupRule::DeleteRule(uint32_t aIndex) { - CSSStyleSheet* sheet = GetStyleSheet(); - NS_ENSURE_TRUE(sheet, NS_ERROR_FAILURE); + ErrorResult rv; + DeleteRule(aIndex, rv); + return rv.StealNSResult(); +} - if (aIndex >= uint32_t(mRules.Count())) - return NS_ERROR_DOM_INDEX_SIZE_ERR; +void +GroupRule::DeleteRule(uint32_t aIndex, ErrorResult& aRv) +{ + CSSStyleSheet* sheet = GetStyleSheet(); + if (NS_WARN_IF(!sheet)) { + aRv.Throw(NS_ERROR_FAILURE); + return; + } + + if (aIndex >= uint32_t(mRules.Count())) { + aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); + return; + } NS_ASSERTION(uint32_t(mRules.Count()) <= INT32_MAX, "Too many style rules!"); - return sheet->DeleteRuleFromGroup(this, aIndex); + nsresult rv = sheet->DeleteRuleFromGroup(this, aIndex); + if (NS_FAILED(rv)) { + aRv.Throw(rv); + } } /* virtual */ size_t @@ -589,17 +706,30 @@ GroupRule::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const return n; } +ConditionRule::ConditionRule(uint32_t aLineNumber, uint32_t aColumnNumber) + : GroupRule(aLineNumber, aColumnNumber) +{ +} + +ConditionRule::ConditionRule(const ConditionRule& aCopy) + : GroupRule(aCopy) +{ +} + +ConditionRule::~ConditionRule() +{ +} // ------------------------------------------- // nsICSSMediaRule // MediaRule::MediaRule(uint32_t aLineNumber, uint32_t aColumnNumber) - : GroupRule(aLineNumber, aColumnNumber) + : ConditionRule(aLineNumber, aColumnNumber) { } MediaRule::MediaRule(const MediaRule& aCopy) - : GroupRule(aCopy) + : ConditionRule(aCopy) { if (aCopy.mMedia) { mMedia = aCopy.mMedia->Clone(); @@ -615,31 +745,18 @@ MediaRule::~MediaRule() } } -NS_IMPL_ADDREF_INHERITED(MediaRule, GroupRule) -NS_IMPL_RELEASE_INHERITED(MediaRule, GroupRule) +NS_IMPL_ADDREF_INHERITED(MediaRule, ConditionRule) +NS_IMPL_RELEASE_INHERITED(MediaRule, ConditionRule) // QueryInterface implementation for MediaRule NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(MediaRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSGroupingRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSConditionRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSMediaRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSMediaRule) -NS_INTERFACE_MAP_END_INHERITING(GroupRule) +NS_INTERFACE_MAP_END_INHERITING(ConditionRule) -NS_IMPL_CYCLE_COLLECTION_CLASS(MediaRule) - -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MediaRule, GroupRule) - if (tmp->mMedia) { - tmp->mMedia->SetStyleSheet(nullptr); - tmp->mMedia = nullptr; - } -NS_IMPL_CYCLE_COLLECTION_UNLINK_END - -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MediaRule, GroupRule) - NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mMedia) -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END +NS_IMPL_CYCLE_COLLECTION_INHERITED(MediaRule, ConditionRule, + mMedia) /* virtual */ void MediaRule::SetStyleSheet(CSSStyleSheet* aSheet) @@ -702,45 +819,26 @@ MediaRule::SetMedia(nsMediaList* aMedia) return NS_OK; } -// nsIDOMCSSRule methods -NS_IMETHODIMP -MediaRule::GetType(uint16_t* aType) +uint16_t +MediaRule::Type() const { - *aType = nsIDOMCSSRule::MEDIA_RULE; - return NS_OK; + return nsIDOMCSSRule::MEDIA_RULE; } -NS_IMETHODIMP -MediaRule::GetCssText(nsAString& aCssText) +nsMediaList* +MediaRule::Media() const +{ + // In practice, if we end up being parsed at all, we have non-null mMedia. So + // it's OK to claim we don't return null here. + return mMedia; +} + +void +MediaRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@media "); AppendConditionText(aCssText); GroupRule::AppendRulesToCssText(aCssText); - return NS_OK; -} - -NS_IMETHODIMP -MediaRule::SetCssText(const nsAString& aCssText) -{ - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -MediaRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return GroupRule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -MediaRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return GroupRule::GetParentRule(aParentRule); -} - -css::Rule* -MediaRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } // nsIDOMCSSGroupingRule methods @@ -773,6 +871,15 @@ MediaRule::GetConditionText(nsAString& aConditionText) NS_IMETHODIMP MediaRule::SetConditionText(const nsAString& aConditionText) +{ + ErrorResult rv; + SetConditionText(aConditionText, rv); + return rv.StealNSResult(); +} + +void +MediaRule::SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) { if (!mMedia) { RefPtr media = new nsMediaList(); @@ -780,11 +887,16 @@ MediaRule::SetConditionText(const nsAString& aConditionText) nsresult rv = media->SetMediaText(aConditionText); if (NS_SUCCEEDED(rv)) { mMedia = media; + } else { + aRv.Throw(rv); } - return rv; + return; } - return mMedia->SetMediaText(aConditionText); + nsresult rv = mMedia->SetMediaText(aConditionText); + if (NS_FAILED(rv)) { + aRv.Throw(rv); + } } // nsIDOMCSSMediaRule methods @@ -820,8 +932,14 @@ MediaRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const return n; } +/* virtual */ JSObject* +MediaRule::WrapObject(JSContext* aCx, JS::Handle aGivenProto) +{ + return CSSMediaRuleBinding::Wrap(aCx, this, aGivenProto); +} + void -MediaRule::AppendConditionText(nsAString& aOutput) +MediaRule::AppendConditionText(nsAString& aOutput) const { if (mMedia) { nsAutoString mediaText; @@ -831,12 +949,12 @@ MediaRule::AppendConditionText(nsAString& aOutput) } DocumentRule::DocumentRule(uint32_t aLineNumber, uint32_t aColumnNumber) - : GroupRule(aLineNumber, aColumnNumber) + : ConditionRule(aLineNumber, aColumnNumber) { } DocumentRule::DocumentRule(const DocumentRule& aCopy) - : GroupRule(aCopy) + : ConditionRule(aCopy) , mURLs(new URL(*aCopy.mURLs)) { } @@ -845,18 +963,15 @@ DocumentRule::~DocumentRule() { } -NS_IMPL_ADDREF_INHERITED(DocumentRule, GroupRule) -NS_IMPL_RELEASE_INHERITED(DocumentRule, GroupRule) +NS_IMPL_ADDREF_INHERITED(DocumentRule, ConditionRule) +NS_IMPL_RELEASE_INHERITED(DocumentRule, ConditionRule) // QueryInterface implementation for DocumentRule NS_INTERFACE_MAP_BEGIN(DocumentRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSGroupingRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSConditionRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSMozDocumentRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSMozDocumentRule) -NS_INTERFACE_MAP_END_INHERITING(GroupRule) +NS_INTERFACE_MAP_END_INHERITING(ConditionRule) #ifdef DEBUG /* virtual */ void @@ -911,46 +1026,19 @@ DocumentRule::Clone() const return clone.forget(); } -// nsIDOMCSSRule methods -NS_IMETHODIMP -DocumentRule::GetType(uint16_t* aType) +uint16_t +DocumentRule::Type() const { // XXX What should really happen here? - *aType = nsIDOMCSSRule::UNKNOWN_RULE; - return NS_OK; + return nsIDOMCSSRule::UNKNOWN_RULE; } -NS_IMETHODIMP -DocumentRule::GetCssText(nsAString& aCssText) +void +DocumentRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@-moz-document "); AppendConditionText(aCssText); GroupRule::AppendRulesToCssText(aCssText); - return NS_OK; -} - -NS_IMETHODIMP -DocumentRule::SetCssText(const nsAString& aCssText) -{ - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -DocumentRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return GroupRule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -DocumentRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return GroupRule::GetParentRule(aParentRule); -} - -css::Rule* -DocumentRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } // nsIDOMCSSGroupingRule methods @@ -987,6 +1075,13 @@ DocumentRule::SetConditionText(const nsAString& aConditionText) return NS_ERROR_NOT_IMPLEMENTED; } +void +DocumentRule::SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) +{ + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); +} + // GroupRule interface /* virtual */ bool DocumentRule::UseForPresentation(nsPresContext* aPresContext, @@ -1062,8 +1157,15 @@ DocumentRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const return n; } +/* virtual */ JSObject* +DocumentRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSMozDocumentRuleBinding::Wrap(aCx, this, aGivenProto); +} + void -DocumentRule::AppendConditionText(nsAString& aCssText) +DocumentRule::AppendConditionText(nsAString& aCssText) const { for (URL *url = mURLs; url; url = url->next) { switch (url->func) { @@ -1110,10 +1212,12 @@ NameSpaceRule::~NameSpaceRule() { } -NS_IMPL_ADDREF(NameSpaceRule) -NS_IMPL_RELEASE(NameSpaceRule) +NS_IMPL_ADDREF_INHERITED(NameSpaceRule, Rule) +NS_IMPL_RELEASE_INHERITED(NameSpaceRule, Rule) // QueryInterface implementation for NameSpaceRule +// If this ever gets its own cycle-collection bits, reevaluate our IsCCLeaf +// implementation. NS_INTERFACE_MAP_BEGIN(NameSpaceRule) if (aIID.Equals(NS_GET_IID(css::NameSpaceRule))) { *aInstancePtr = this; @@ -1121,12 +1225,13 @@ NS_INTERFACE_MAP_BEGIN(NameSpaceRule) return NS_OK; } else - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSNameSpaceRule) -NS_INTERFACE_MAP_END +NS_INTERFACE_MAP_END_INHERITING(Rule) -IMPL_STYLE_RULE_INHERIT(NameSpaceRule, Rule) +bool +NameSpaceRule::IsCCLeaf() const +{ + return Rule::IsCCLeaf(); +} #ifdef DEBUG /* virtual */ void @@ -1167,15 +1272,14 @@ NameSpaceRule::Clone() const return clone.forget(); } -NS_IMETHODIMP -NameSpaceRule::GetType(uint16_t* aType) +uint16_t +NameSpaceRule::Type() const { - *aType = nsIDOMCSSRule::NAMESPACE_RULE; - return NS_OK; + return nsIDOMCSSRule::NAMESPACE_RULE; } -NS_IMETHODIMP -NameSpaceRule::GetCssText(nsAString& aCssText) +void +NameSpaceRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@namespace "); if (mPrefix) { @@ -1184,31 +1288,6 @@ NameSpaceRule::GetCssText(nsAString& aCssText) aCssText.AppendLiteral("url("); nsStyleUtil::AppendEscapedCSSString(mURLSpec, aCssText); aCssText.AppendLiteral(");"); - return NS_OK; -} - -NS_IMETHODIMP -NameSpaceRule::SetCssText(const nsAString& aCssText) -{ - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -NameSpaceRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -NameSpaceRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -NameSpaceRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } /* virtual */ size_t @@ -1222,6 +1301,12 @@ NameSpaceRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const // - mURLSpec } +/* virtual */ JSObject* +NameSpaceRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSNamespaceRuleBinding::Wrap(aCx, this, aGivenProto); +} } // namespace css } // namespace mozilla @@ -1352,7 +1437,14 @@ nsCSSFontFaceStyleDecl::GetPropertyValue(nsCSSFontDesc aFontDescID, NS_IMETHODIMP -nsCSSFontFaceStyleDecl::GetCssText(nsAString & aCssText) +nsCSSFontFaceStyleDecl::GetCssText(nsAString& aCssText) +{ + GetCssTextImpl(aCssText); + return NS_OK; +} + +void +nsCSSFontFaceStyleDecl::GetCssTextImpl(nsAString& aCssText) const { nsAutoString descStr; @@ -1371,7 +1463,6 @@ nsCSSFontFaceStyleDecl::GetCssText(nsAString & aCssText) aCssText.AppendLiteral(";\n"); } } - return NS_OK; } NS_IMETHODIMP @@ -1488,7 +1579,7 @@ nsCSSFontFaceStyleDecl::IndexedGetter(uint32_t index, bool& aFound, nsAString & NS_IMETHODIMP nsCSSFontFaceStyleDecl::GetParentRule(nsIDOMCSSRule** aParentRule) { - NS_IF_ADDREF(*aParentRule = ContainingRule()->GetDOMRule()); + NS_IF_ADDREF(*aParentRule = ContainingRule()); return NS_OK; } @@ -1539,37 +1630,50 @@ nsCSSFontFaceRule::Clone() const return clone.forget(); } -NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCSSFontFaceRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(nsCSSFontFaceRule) +NS_IMPL_ADDREF_INHERITED(nsCSSFontFaceRule, mozilla::css::Rule) +NS_IMPL_RELEASE_INHERITED(nsCSSFontFaceRule, mozilla::css::Rule) NS_IMPL_CYCLE_COLLECTION_CLASS(nsCSSFontFaceRule) -NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsCSSFontFaceRule) +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(nsCSSFontFaceRule, + mozilla::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->mDecl.TraceWrapper(aCallbacks, aClosure); NS_IMPL_CYCLE_COLLECTION_TRACE_END -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsCSSFontFaceRule) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsCSSFontFaceRule, + mozilla::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->mDecl.ReleaseWrapper(static_cast(p)); NS_IMPL_CYCLE_COLLECTION_UNLINK_END -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsCSSFontFaceRule) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsCSSFontFaceRule, + mozilla::css::Rule) + // Keep this in sync with IsCCLeaf. NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END -// QueryInterface implementation for nsCSSFontFaceRule -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCSSFontFaceRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSFontFaceRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSFontFaceRule) -NS_INTERFACE_MAP_END +bool +nsCSSFontFaceRule::IsCCLeaf() const +{ + if (!Rule::IsCCLeaf()) { + return false; + } -IMPL_STYLE_RULE_INHERIT(nsCSSFontFaceRule, Rule) + return !mDecl.PreservingWrapper(); +} + +// QueryInterface implementation for nsCSSFontFaceRule +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsCSSFontFaceRule) + NS_INTERFACE_MAP_ENTRY(nsIDOMCSSFontFaceRule) +NS_INTERFACE_MAP_END_INHERITING(Rule) #ifdef DEBUG void @@ -1607,47 +1711,27 @@ nsCSSFontFaceRule::GetType() const return Rule::FONT_FACE_RULE; } -NS_IMETHODIMP -nsCSSFontFaceRule::GetType(uint16_t* aType) +uint16_t +nsCSSFontFaceRule::Type() const { - *aType = nsIDOMCSSRule::FONT_FACE_RULE; - return NS_OK; + return nsIDOMCSSRule::FONT_FACE_RULE; } -NS_IMETHODIMP -nsCSSFontFaceRule::GetCssText(nsAString& aCssText) +void +nsCSSFontFaceRule::GetCssTextImpl(nsAString& aCssText) const { nsAutoString propText; - mDecl.GetCssText(propText); + mDecl.GetCssTextImpl(propText); aCssText.AssignLiteral("@font-face {\n"); aCssText.Append(propText); aCssText.Append('}'); - return NS_OK; } -NS_IMETHODIMP -nsCSSFontFaceRule::SetCssText(const nsAString& aCssText) +nsICSSDeclaration* +nsCSSFontFaceRule::Style() { - return NS_ERROR_NOT_IMPLEMENTED; // bug 443978 -} - -NS_IMETHODIMP -nsCSSFontFaceRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSFontFaceRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSFontFaceRule::GetCSSRule() -{ - return Rule::GetCSSRule(); + return &mDecl; } NS_IMETHODIMP @@ -1690,6 +1774,12 @@ nsCSSFontFaceRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const // - mDecl } +/* virtual */ JSObject* +nsCSSFontFaceRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSFontFaceRuleBinding::Wrap(aCx, this, aGivenProto); +} // ----------------------------------- // nsCSSFontFeatureValuesRule @@ -1702,18 +1792,21 @@ nsCSSFontFeatureValuesRule::Clone() const return clone.forget(); } -NS_IMPL_ADDREF(nsCSSFontFeatureValuesRule) -NS_IMPL_RELEASE(nsCSSFontFeatureValuesRule) +NS_IMPL_ADDREF_INHERITED(nsCSSFontFeatureValuesRule, mozilla::css::Rule) +NS_IMPL_RELEASE_INHERITED(nsCSSFontFeatureValuesRule, mozilla::css::Rule) // QueryInterface implementation for nsCSSFontFeatureValuesRule +// If this ever gets its own cycle-collection bits, reevaluate our IsCCLeaf +// implementation. NS_INTERFACE_MAP_BEGIN(nsCSSFontFeatureValuesRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSFontFeatureValuesRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSFontFeatureValuesRule) -NS_INTERFACE_MAP_END +NS_INTERFACE_MAP_END_INHERITING(mozilla::css::Rule) -IMPL_STYLE_RULE_INHERIT(nsCSSFontFeatureValuesRule, Rule) +bool +nsCSSFontFeatureValuesRule::IsCCLeaf() const +{ + return Rule::IsCCLeaf(); +} static void FeatureValuesToString( @@ -1803,43 +1896,30 @@ nsCSSFontFeatureValuesRule::GetType() const return Rule::FONT_FEATURE_VALUES_RULE; } -NS_IMETHODIMP -nsCSSFontFeatureValuesRule::GetType(uint16_t* aType) +uint16_t +nsCSSFontFeatureValuesRule::Type() const { - *aType = nsIDOMCSSRule::FONT_FEATURE_VALUES_RULE; - return NS_OK; + return nsIDOMCSSRule::FONT_FEATURE_VALUES_RULE; } -NS_IMETHODIMP -nsCSSFontFeatureValuesRule::GetCssText(nsAString& aCssText) +void +nsCSSFontFeatureValuesRule::GetCssTextImpl(nsAString& aCssText) const { FontFeatureValuesRuleToString(mFamilyList, mFeatureValues, aCssText); - return NS_OK; } -NS_IMETHODIMP -nsCSSFontFeatureValuesRule::SetCssText(const nsAString& aCssText) +void +nsCSSFontFeatureValuesRule::SetFontFamily(const nsAString& aFamily, + ErrorResult& aRv) { - // FIXME: implement??? - return NS_ERROR_NOT_IMPLEMENTED; + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); } -NS_IMETHODIMP -nsCSSFontFeatureValuesRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) +void +nsCSSFontFeatureValuesRule::SetValueText(const nsAString& aFamily, + ErrorResult& aRv) { - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSFontFeatureValuesRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSFontFeatureValuesRule::GetCSSRule() -{ - return Rule::GetCSSRule(); + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); } NS_IMETHODIMP @@ -1930,6 +2010,13 @@ nsCSSFontFeatureValuesRule::SizeOfIncludingThis( return aMallocSizeOf(this); } +/* virtual */ JSObject* +nsCSSFontFeatureValuesRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSFontFeatureValuesRuleBinding::Wrap(aCx, this, aGivenProto); +} + // ------------------------------------------- // nsCSSKeyframeStyleDeclaration // @@ -2037,30 +2124,33 @@ nsCSSKeyframeRule::Clone() const return clone.forget(); } -NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCSSKeyframeRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(nsCSSKeyframeRule) +NS_IMPL_ADDREF_INHERITED(nsCSSKeyframeRule, mozilla::css::Rule) +NS_IMPL_RELEASE_INHERITED(nsCSSKeyframeRule, mozilla::css::Rule) NS_IMPL_CYCLE_COLLECTION_CLASS(nsCSSKeyframeRule) -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsCSSKeyframeRule) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsCSSKeyframeRule, mozilla::css::Rule) if (tmp->mDOMDeclaration) { tmp->mDOMDeclaration->DropReference(); tmp->mDOMDeclaration = nullptr; } NS_IMPL_CYCLE_COLLECTION_UNLINK_END -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsCSSKeyframeRule) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsCSSKeyframeRule, mozilla::css::Rule) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDOMDeclaration) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END -// QueryInterface implementation for nsCSSKeyframeRule -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCSSKeyframeRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSKeyframeRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSKeyframeRule) -NS_INTERFACE_MAP_END +bool +nsCSSKeyframeRule::IsCCLeaf() const +{ + // Let's not worry about figuring out whether we're a leaf or not. + return false; +} -IMPL_STYLE_RULE_INHERIT_GET_DOM_RULE_WEAK(nsCSSKeyframeRule, Rule) +// QueryInterface implementation for nsCSSKeyframeRule +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsCSSKeyframeRule) + NS_INTERFACE_MAP_ENTRY(nsIDOMCSSKeyframeRule) +NS_INTERFACE_MAP_END_INHERITING(mozilla::css::Rule) #ifdef DEBUG void @@ -2088,15 +2178,14 @@ nsCSSKeyframeRule::GetType() const return Rule::KEYFRAME_RULE; } -NS_IMETHODIMP -nsCSSKeyframeRule::GetType(uint16_t* aType) +uint16_t +nsCSSKeyframeRule::Type() const { - *aType = nsIDOMCSSRule::KEYFRAME_RULE; - return NS_OK; + return nsIDOMCSSRule::KEYFRAME_RULE; } -NS_IMETHODIMP -nsCSSKeyframeRule::GetCssText(nsAString& aCssText) +void +nsCSSKeyframeRule::GetCssTextImpl(nsAString& aCssText) const { DoGetKeyText(aCssText); aCssText.AppendLiteral(" { "); @@ -2104,32 +2193,6 @@ nsCSSKeyframeRule::GetCssText(nsAString& aCssText) mDeclaration->ToString(tmp); aCssText.Append(tmp); aCssText.AppendLiteral(" }"); - return NS_OK; -} - -NS_IMETHODIMP -nsCSSKeyframeRule::SetCssText(const nsAString& aCssText) -{ - // FIXME: implement??? - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -nsCSSKeyframeRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSKeyframeRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSKeyframeRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } NS_IMETHODIMP @@ -2186,12 +2249,18 @@ nsCSSKeyframeRule::SetKeyText(const nsAString& aKeyText) NS_IMETHODIMP nsCSSKeyframeRule::GetStyle(nsIDOMCSSStyleDeclaration** aStyle) +{ + NS_ADDREF(*aStyle = Style()); + return NS_OK; +} + +nsICSSDeclaration* +nsCSSKeyframeRule::Style() { if (!mDOMDeclaration) { mDOMDeclaration = new nsCSSKeyframeStyleDeclaration(this); } - NS_ADDREF(*aStyle = mDOMDeclaration); - return NS_OK; + return mDOMDeclaration; } void @@ -2231,6 +2300,12 @@ nsCSSKeyframeRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const // - mDOMDeclaration } +/* virtual */ JSObject* +nsCSSKeyframeRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSKeyframeRuleBinding::Wrap(aCx, this, aGivenProto); +} // ------------------------------------------- // nsCSSKeyframesRule @@ -2261,10 +2336,7 @@ NS_IMPL_RELEASE_INHERITED(nsCSSKeyframesRule, css::GroupRule) // QueryInterface implementation for nsCSSKeyframesRule NS_INTERFACE_MAP_BEGIN(nsCSSKeyframesRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSKeyframesRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSKeyframesRule) NS_INTERFACE_MAP_END_INHERITING(GroupRule) #ifdef DEBUG @@ -2291,15 +2363,14 @@ nsCSSKeyframesRule::GetType() const return Rule::KEYFRAMES_RULE; } -NS_IMETHODIMP -nsCSSKeyframesRule::GetType(uint16_t* aType) +uint16_t +nsCSSKeyframesRule::Type() const { - *aType = nsIDOMCSSRule::KEYFRAMES_RULE; - return NS_OK; + return nsIDOMCSSRule::KEYFRAMES_RULE; } -NS_IMETHODIMP -nsCSSKeyframesRule::GetCssText(nsAString& aCssText) +void +nsCSSKeyframesRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@keyframes "); aCssText.Append(mName); @@ -2311,32 +2382,6 @@ nsCSSKeyframesRule::GetCssText(nsAString& aCssText) aCssText.Append('\n'); } aCssText.Append('}'); - return NS_OK; -} - -NS_IMETHODIMP -nsCSSKeyframesRule::SetCssText(const nsAString& aCssText) -{ - // FIXME: implement??? - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -nsCSSKeyframesRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return GroupRule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSKeyframesRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return GroupRule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSKeyframesRule::GetCSSRule() -{ - return GroupRule::GetCSSRule(); } NS_IMETHODIMP @@ -2456,14 +2501,19 @@ nsCSSKeyframesRule::DeleteRule(const nsAString& aKey) NS_IMETHODIMP nsCSSKeyframesRule::FindRule(const nsAString& aKey, nsIDOMCSSKeyframeRule** aResult) +{ + NS_IF_ADDREF(*aResult = FindRule(aKey)); + return NS_OK; +} + +nsCSSKeyframeRule* +nsCSSKeyframesRule::FindRule(const nsAString& aKey) { uint32_t index = FindRuleIndexForKey(aKey); if (index == RULE_NOT_FOUND) { - *aResult = nullptr; - } else { - NS_ADDREF(*aResult = static_cast(mRules[index])); + return nullptr; } - return NS_OK; + return static_cast(mRules[index]); } // GroupRule interface @@ -2488,6 +2538,13 @@ nsCSSKeyframesRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const return n; } +/* virtual */ JSObject* +nsCSSKeyframesRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSKeyframesRuleBinding::Wrap(aCx, this, aGivenProto); +} + // ------------------------------------------- // nsCSSPageStyleDeclaration // @@ -2594,30 +2651,33 @@ nsCSSPageRule::Clone() const return clone.forget(); } -NS_IMPL_CYCLE_COLLECTING_ADDREF(nsCSSPageRule) -NS_IMPL_CYCLE_COLLECTING_RELEASE(nsCSSPageRule) +NS_IMPL_ADDREF_INHERITED(nsCSSPageRule, mozilla::css::Rule) +NS_IMPL_RELEASE_INHERITED(nsCSSPageRule, mozilla::css::Rule) NS_IMPL_CYCLE_COLLECTION_CLASS(nsCSSPageRule) -NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsCSSPageRule) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsCSSPageRule, mozilla::css::Rule) if (tmp->mDOMDeclaration) { tmp->mDOMDeclaration->DropReference(); tmp->mDOMDeclaration = nullptr; } NS_IMPL_CYCLE_COLLECTION_UNLINK_END -NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsCSSPageRule) + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsCSSPageRule, mozilla::css::Rule) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDOMDeclaration) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END -// QueryInterface implementation for nsCSSPageRule -NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsCSSPageRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSPageRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSPageRule) -NS_INTERFACE_MAP_END +bool +nsCSSPageRule::IsCCLeaf() const +{ + // Let's not worry about figuring out whether we're a leaf or not. + return false; +} -IMPL_STYLE_RULE_INHERIT_GET_DOM_RULE_WEAK(nsCSSPageRule, Rule) +// QueryInterface implementation for nsCSSPageRule +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsCSSPageRule) + NS_INTERFACE_MAP_ENTRY(nsIDOMCSSPageRule) +NS_INTERFACE_MAP_END_INHERITING(mozilla::css::Rule) #ifdef DEBUG void @@ -2643,57 +2703,36 @@ nsCSSPageRule::GetType() const return Rule::PAGE_RULE; } -NS_IMETHODIMP -nsCSSPageRule::GetType(uint16_t* aType) +uint16_t +nsCSSPageRule::Type() const { - *aType = nsIDOMCSSRule::PAGE_RULE; - return NS_OK; + return nsIDOMCSSRule::PAGE_RULE; } -NS_IMETHODIMP -nsCSSPageRule::GetCssText(nsAString& aCssText) +void +nsCSSPageRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AppendLiteral("@page { "); nsAutoString tmp; mDeclaration->ToString(tmp); aCssText.Append(tmp); aCssText.AppendLiteral(" }"); - return NS_OK; -} - -NS_IMETHODIMP -nsCSSPageRule::SetCssText(const nsAString& aCssText) -{ - // FIXME: implement??? - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -nsCSSPageRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSPageRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSPageRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } NS_IMETHODIMP nsCSSPageRule::GetStyle(nsIDOMCSSStyleDeclaration** aStyle) +{ + NS_ADDREF(*aStyle = Style()); + return NS_OK; +} + +nsICSSDeclaration* +nsCSSPageRule::Style() { if (!mDOMDeclaration) { mDOMDeclaration = new nsCSSPageStyleDeclaration(this); } - NS_ADDREF(*aStyle = mDOMDeclaration); - return NS_OK; + return mDOMDeclaration; } void @@ -2717,12 +2756,19 @@ nsCSSPageRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const return aMallocSizeOf(this); } +/* virtual */ JSObject* +nsCSSPageRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSPageRuleBinding::Wrap(aCx, this, aGivenProto); +} + namespace mozilla { CSSSupportsRule::CSSSupportsRule(bool aConditionMet, const nsString& aCondition, uint32_t aLineNumber, uint32_t aColumnNumber) - : css::GroupRule(aLineNumber, aColumnNumber) + : css::ConditionRule(aLineNumber, aColumnNumber) , mUseGroup(aConditionMet) , mCondition(aCondition) { @@ -2733,7 +2779,7 @@ CSSSupportsRule::~CSSSupportsRule() } CSSSupportsRule::CSSSupportsRule(const CSSSupportsRule& aCopy) - : css::GroupRule(aCopy), + : css::ConditionRule(aCopy), mUseGroup(aCopy.mUseGroup), mCondition(aCopy.mCondition) { @@ -2777,58 +2823,28 @@ CSSSupportsRule::UseForPresentation(nsPresContext* aPresContext, return mUseGroup; } -NS_IMPL_ADDREF_INHERITED(CSSSupportsRule, css::GroupRule) -NS_IMPL_RELEASE_INHERITED(CSSSupportsRule, css::GroupRule) +NS_IMPL_ADDREF_INHERITED(CSSSupportsRule, css::ConditionRule) +NS_IMPL_RELEASE_INHERITED(CSSSupportsRule, css::ConditionRule) // QueryInterface implementation for CSSSupportsRule NS_INTERFACE_MAP_BEGIN(CSSSupportsRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSGroupingRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSConditionRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSSupportsRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSSupportsRule) -NS_INTERFACE_MAP_END_INHERITING(GroupRule) +NS_INTERFACE_MAP_END_INHERITING(ConditionRule) -// nsIDOMCSSRule methods -NS_IMETHODIMP -CSSSupportsRule::GetType(uint16_t* aType) +uint16_t +CSSSupportsRule::Type() const { - *aType = nsIDOMCSSRule::SUPPORTS_RULE; - return NS_OK; + return nsIDOMCSSRule::SUPPORTS_RULE; } -NS_IMETHODIMP -CSSSupportsRule::GetCssText(nsAString& aCssText) +void +CSSSupportsRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral("@supports "); aCssText.Append(mCondition); css::GroupRule::AppendRulesToCssText(aCssText); - return NS_OK; -} - -NS_IMETHODIMP -CSSSupportsRule::SetCssText(const nsAString& aCssText) -{ - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -CSSSupportsRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return css::GroupRule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -CSSSupportsRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return css::GroupRule::GetParentRule(aParentRule); -} - -css::Rule* -CSSSupportsRule::GetCSSRule() -{ - return css::GroupRule::GetCSSRule(); } // nsIDOMCSSGroupingRule methods @@ -2864,6 +2880,13 @@ CSSSupportsRule::SetConditionText(const nsAString& aConditionText) return NS_ERROR_NOT_IMPLEMENTED; } +void +CSSSupportsRule::SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) +{ + aRv.Throw(NS_ERROR_NOT_IMPLEMENTED); +} + /* virtual */ size_t CSSSupportsRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { @@ -2873,6 +2896,13 @@ CSSSupportsRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const return n; } +/* virtual */ JSObject* +CSSSupportsRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSSupportsRuleBinding::Wrap(aCx, this, aGivenProto); +} + } // namespace mozilla // ------------------------------------------- @@ -2907,18 +2937,21 @@ nsCSSCounterStyleRule::kGetters[] = { #undef CSS_COUNTER_DESC }; -NS_IMPL_ADDREF(nsCSSCounterStyleRule) -NS_IMPL_RELEASE(nsCSSCounterStyleRule) +NS_IMPL_ADDREF_INHERITED(nsCSSCounterStyleRule, mozilla::css::Rule) +NS_IMPL_RELEASE_INHERITED(nsCSSCounterStyleRule, mozilla::css::Rule) // QueryInterface implementation for nsCSSCounterStyleRule +// If this ever gets its own cycle-collection bits, reevaluate our IsCCLeaf +// implementation. NS_INTERFACE_MAP_BEGIN(nsCSSCounterStyleRule) - NS_INTERFACE_MAP_ENTRY(nsIDOMCSSRule) NS_INTERFACE_MAP_ENTRY(nsIDOMCSSCounterStyleRule) - NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozilla::css::Rule) - NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CSSCounterStyleRule) -NS_INTERFACE_MAP_END +NS_INTERFACE_MAP_END_INHERITING(mozilla::css::Rule) -IMPL_STYLE_RULE_INHERIT(nsCSSCounterStyleRule, css::Rule) +bool +nsCSSCounterStyleRule::IsCCLeaf() const +{ + return Rule::IsCCLeaf(); +} #ifdef DEBUG void @@ -2945,16 +2978,14 @@ nsCSSCounterStyleRule::GetType() const return Rule::COUNTER_STYLE_RULE; } -// nsIDOMCSSRule methods -NS_IMETHODIMP -nsCSSCounterStyleRule::GetType(uint16_t* aType) +uint16_t +nsCSSCounterStyleRule::Type() const { - *aType = nsIDOMCSSRule::COUNTER_STYLE_RULE; - return NS_OK; + return nsIDOMCSSRule::COUNTER_STYLE_RULE; } -NS_IMETHODIMP -nsCSSCounterStyleRule::GetCssText(nsAString& aCssText) +void +nsCSSCounterStyleRule::GetCssTextImpl(nsAString& aCssText) const { aCssText.AssignLiteral(u"@counter-style "); nsStyleUtil::AppendEscapedCSSIdent(mName, aCssText); @@ -2964,7 +2995,10 @@ nsCSSCounterStyleRule::GetCssText(nsAString& aCssText) id = nsCSSCounterDesc(id + 1)) { if (mValues[id].GetUnit() != eCSSUnit_Null) { nsAutoString tmp; - (this->*kGetters[id])(tmp); + // This is annoying. We want to be a const method, but kGetters stores + // XPCOM method pointers, which aren't const methods. The thing is, + // none of those mutate "this". So it's OK to cast away const here. + (const_cast(this)->*kGetters[id])(tmp); aCssText.AppendLiteral(u" "); AppendASCIItoUTF16(nsCSSProps::GetStringValue(id), aCssText); aCssText.AppendLiteral(u": "); @@ -2973,32 +3007,6 @@ nsCSSCounterStyleRule::GetCssText(nsAString& aCssText) } } aCssText.AppendLiteral(u"}"); - return NS_OK; -} - -NS_IMETHODIMP -nsCSSCounterStyleRule::SetCssText(const nsAString& aCssText) -{ - // FIXME: implement??? - return NS_ERROR_NOT_IMPLEMENTED; -} - -NS_IMETHODIMP -nsCSSCounterStyleRule::GetParentStyleSheet(nsIDOMCSSStyleSheet** aSheet) -{ - return Rule::GetParentStyleSheet(aSheet); -} - -NS_IMETHODIMP -nsCSSCounterStyleRule::GetParentRule(nsIDOMCSSRule** aParentRule) -{ - return Rule::GetParentRule(aParentRule); -} - -css::Rule* -nsCSSCounterStyleRule::GetCSSRule() -{ - return Rule::GetCSSRule(); } // nsIDOMCSSCounterStyleRule methods @@ -3336,3 +3344,10 @@ nsCSSCounterStyleRule::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { return aMallocSizeOf(this); } + +/* virtual */ JSObject* +nsCSSCounterStyleRule::WrapObject(JSContext* aCx, + JS::Handle aGivenProto) +{ + return CSSCounterStyleRuleBinding::Wrap(aCx, this, aGivenProto); +} diff --git a/layout/style/nsCSSRules.h b/layout/style/nsCSSRules.h index 9c3196575c..6dc9b141cc 100644 --- a/layout/style/nsCSSRules.h +++ b/layout/style/nsCSSRules.h @@ -46,7 +46,7 @@ class ErrorResult; namespace css { -class MediaRule final : public GroupRule, +class MediaRule final : public ConditionRule, public nsIDOMCSSMediaRule { public: @@ -56,7 +56,7 @@ private: ~MediaRule(); public: - NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MediaRule, GroupRule) + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MediaRule, ConditionRule) NS_DECL_ISUPPORTS_INHERITED // Rule methods @@ -65,18 +65,8 @@ public: #endif virtual void SetStyleSheet(mozilla::CSSStyleSheet* aSheet) override; //override GroupRule virtual int32_t GetType() const override; + using Rule::GetType; virtual already_AddRefed 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 @@ -93,17 +83,28 @@ public: // @media rule methods nsresult SetMedia(nsMediaList* aMedia); - + + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // Our XPCOM GetConditionText is OK + virtual void SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) override; + nsMediaList* Media() const; + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override MOZ_MUST_OVERRIDE; + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + protected: - void AppendConditionText(nsAString& aOutput); + void AppendConditionText(nsAString& aOutput) const; RefPtr mMedia; }; -class DocumentRule final : public GroupRule, +class DocumentRule final : public ConditionRule, public nsIDOMCSSMozDocumentRule { public: @@ -120,18 +121,8 @@ public: virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override; #endif virtual int32_t GetType() const override; + using Rule::GetType; virtual already_AddRefed 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 @@ -172,11 +163,21 @@ public: void SetURLs(URL *aURLs) { mURLs = aURLs; } + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // Our XPCOM GetConditionText is OK + virtual void SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) override; + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override MOZ_MUST_OVERRIDE; + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + protected: - void AppendConditionText(nsAString& aOutput); + void AppendConditionText(nsAString& aOutput) const; nsAutoPtr mURLs; // linked list of |struct URL| above. }; @@ -230,6 +231,9 @@ protected: mozilla::CSSFontFaceDescriptors mDescriptors; + // The actual implementation of GetCssText, so we can make it const. + void GetCssTextImpl(nsAString& aCssText) const; + private: // NOT TO BE IMPLEMENTED // This object cannot be allocated on its own, only as part of @@ -242,35 +246,44 @@ class nsCSSFontFaceRule final : public mozilla::css::Rule, { public: nsCSSFontFaceRule(uint32_t aLineNumber, uint32_t aColumnNumber) - : mozilla::css::Rule(aLineNumber, aColumnNumber) {} + : mozilla::css::Rule(aLineNumber, aColumnNumber) + { + } nsCSSFontFaceRule(const nsCSSFontFaceRule& aCopy) // copy everything except our reference count - : mozilla::css::Rule(aCopy), mDecl(aCopy.mDecl) {} + : mozilla::css::Rule(aCopy) + , mDecl(aCopy.mDecl) + { + } - NS_DECL_CYCLE_COLLECTING_ISUPPORTS - NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsCSSFontFaceRule, - mozilla::css::Rule) + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(nsCSSFontFaceRule, mozilla::css::Rule) + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed 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); + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + nsICSSDeclaration* Style(); + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, + JS::Handle aGivenProto) override; + void GetDescriptors(mozilla::CSSFontFaceDescriptors& aDescriptors) const { aDescriptors = mDecl.mDescriptors; } @@ -307,30 +320,39 @@ class nsCSSFontFeatureValuesRule final : public mozilla::css::Rule, { public: nsCSSFontFeatureValuesRule(uint32_t aLineNumber, uint32_t aColumnNumber) - : mozilla::css::Rule(aLineNumber, 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) {} + : mozilla::css::Rule(aCopy) + , mFamilyList(aCopy.mFamilyList) + , mFeatureValues(aCopy.mFeatureValues) + { + } - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS_INHERITED + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed Clone() const override; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE - // nsIDOMCSSFontFaceRule interface NS_DECL_NSIDOMCSSFONTFEATUREVALUESRULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // Our XPCOM GetFontFamily is OK + void SetFontFamily(const nsAString& aFamily, mozilla::ErrorResult& aRv); + // Our XPCOM GetValueText is OK + void SetValueText(const nsAString& aFamily, mozilla::ErrorResult& aRv); + const mozilla::FontFamilyList& GetFamilyList() { return mFamilyList; } void SetFamilyList(const mozilla::FontFamilyList& aFamilyList); @@ -344,6 +366,8 @@ public: virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + protected: ~nsCSSFontFeatureValuesRule() {} @@ -398,23 +422,27 @@ private: nsCSSKeyframeRule(const nsCSSKeyframeRule& aCopy); ~nsCSSKeyframeRule(); public: - NS_DECL_CYCLE_COLLECTING_ISUPPORTS - NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSKeyframeRule, mozilla::css::Rule) + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsCSSKeyframeRule, mozilla::css::Rule) + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed Clone() const override; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE - // nsIDOMCSSKeyframeRule interface NS_DECL_NSIDOMCSSKEYFRAMERULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // Our XPCOM GetKeyText is OK. + // Our XPCOM SetKeyText is OK. + nsICSSDeclaration* Style(); + const nsTArray& GetKeys() const { return mKeys; } mozilla::css::Declaration* Declaration() { return mDeclaration; } @@ -422,6 +450,8 @@ public: virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + void DoGetKeyText(nsAString &aKeyText) const; private: @@ -452,22 +482,22 @@ public: virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override; #endif virtual int32_t GetType() const override; + using Rule::GetType; virtual already_AddRefed 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 + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // The XPCOM GetName is OK + // The XPCOM SetName is OK + using mozilla::css::GroupRule::CssRules; + // The XPCOM appendRule is OK, since it never throws + // The XPCOM deleteRule is OK, since it never throws + nsCSSKeyframeRule* FindRule(const nsAString& aKey); + // rest of GroupRule virtual bool UseForPresentation(nsPresContext* aPresContext, nsMediaQueryResultCacheKey& aKey) override; @@ -476,6 +506,8 @@ public: virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + private: uint32_t FindRuleIndexForKey(const nsAString& aKey); @@ -526,28 +558,33 @@ private: nsCSSPageRule(const nsCSSPageRule& aCopy); ~nsCSSPageRule(); public: - NS_DECL_CYCLE_COLLECTING_ISUPPORTS - NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsCSSPageRule, nsIDOMCSSPageRule) + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsCSSPageRule, mozilla::css::Rule) + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed Clone() const override; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE - // nsIDOMCSSPageRule interface NS_DECL_NSIDOMCSSPAGERULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + nsICSSDeclaration* Style(); + mozilla::css::Declaration* Declaration() { return mDeclaration; } void ChangeDeclaration(mozilla::css::Declaration* aDeclaration); virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + private: RefPtr mDeclaration; // lazily created when needed: @@ -556,8 +593,8 @@ private: namespace mozilla { -class CSSSupportsRule : public css::GroupRule, - public nsIDOMCSSSupportsRule +class CSSSupportsRule final : public css::ConditionRule, + public nsIDOMCSSSupportsRule { public: CSSSupportsRule(bool aConditionMet, const nsString& aCondition, @@ -569,23 +606,13 @@ public: virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override; #endif virtual int32_t GetType() const override; + using Rule::GetType; virtual already_AddRefed 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 @@ -595,8 +622,17 @@ public: // nsIDOMCSSSupportsRule interface NS_DECL_NSIDOMCSSSUPPORTSRULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // Our XPCOM GetConditionText is OK + virtual void SetConditionText(const nsAString& aConditionText, + ErrorResult& aRv) override; + virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + protected: virtual ~CSSSupportsRule(); @@ -623,22 +659,45 @@ private: ~nsCSSCounterStyleRule(); public: - NS_DECL_ISUPPORTS + NS_DECL_ISUPPORTS_INHERITED + virtual bool IsCCLeaf() const override; - // 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; + using Rule::GetType; virtual already_AddRefed Clone() const override; - // nsIDOMCSSRule interface - NS_DECL_NSIDOMCSSRULE - // nsIDOMCSSCounterStyleRule NS_DECL_NSIDOMCSSCOUNTERSTYLERULE + // WebIDL interface + uint16_t Type() const override; + void GetCssTextImpl(nsAString& aCssText) const override; + // The XPCOM GetName is OK + // The XPCOM SetName is OK + // The XPCOM GetSystem is OK + // The XPCOM SetSystem is OK + // The XPCOM GetSymbols is OK + // The XPCOM SetSymbols is OK + // The XPCOM GetAdditiveSymbols is OK + // The XPCOM SetAdditiveSymbols is OK + // The XPCOM GetNegative is OK + // The XPCOM SetNegative is OK + // The XPCOM GetPrefix is OK + // The XPCOM SetPrefix is OK + // The XPCOM GetSuffix is OK + // The XPCOM SetSuffix is OK + // The XPCOM GetRange is OK + // The XPCOM SetRange is OK + // The XPCOM GetPad is OK + // The XPCOM SetPad is OK + // The XPCOM GetSpeakAs is OK + // The XPCOM SetSpeakAs is OK + // The XPCOM GetFallback is OK + // The XPCOM SetFallback is OK + // 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, @@ -663,6 +722,8 @@ public: virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override; + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle aGivenProto) override; + private: typedef NS_STDCALL_FUNCPROTO(nsresult, Getter, nsCSSCounterStyleRule, GetSymbols, (nsAString&)); diff --git a/layout/style/nsICSSStyleRuleDOMWrapper.h b/layout/style/nsICSSStyleRuleDOMWrapper.h index 038cca0868..f2a3b6ccc9 100644 --- a/layout/style/nsICSSStyleRuleDOMWrapper.h +++ b/layout/style/nsICSSStyleRuleDOMWrapper.h @@ -18,6 +18,11 @@ #define NS_ICSS_STYLE_RULE_DOM_WRAPPER_IID \ {0xcee1bbb6, 0x0a32, 0x4cf3, {0x8d, 0x42, 0xba, 0x39, 0x38, 0xe9, 0xec, 0xaa}} +namespace mozilla { +namespace css { +class StyleRule; +} // namespace css +} // namespace mozilla class nsICSSStyleRuleDOMWrapper : public nsIDOMCSSStyleRule { public: