1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* base class for DOM objects for element.style and cssStyleRule.style */
#ifndef nsDOMCSSDeclaration_h___
#define nsDOMCSSDeclaration_h___
#include "nsICSSDeclaration.h"
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "mozilla/URLExtraData.h"
#include "nsAttrValue.h"
#include "nsCOMPtr.h"
#include "nsCompatibility.h"
class nsIPrincipal;
struct JSContext;
class JSObject;
namespace mozilla {
enum class StyleCssRuleType : uint8_t;
class DeclarationBlock;
struct DeclarationBlockMutationClosure;
namespace css {
class Loader;
class Rule;
} // namespace css
namespace dom {
class Document;
class Element;
} // namespace dom
struct MutationClosureData {
MutationClosureData() = default;
mozilla::dom::Element* mElement = nullptr;
Maybe<nsAttrValue> mOldValue;
uint8_t mModType = 0;
bool mWasCalled = false;
bool mShouldBeCalled = false;
};
} // namespace mozilla
class nsDOMCSSDeclaration : public nsICSSDeclaration {
public:
// Only implement QueryInterface; subclasses have the responsibility
// of implementing AddRef/Release.
NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
// Declare addref and release so they can be called on us, but don't
// implement them. Our subclasses must handle their own
// refcounting.
NS_IMETHOD_(MozExternalRefCountType) AddRef() override = 0;
NS_IMETHOD_(MozExternalRefCountType) Release() override = 0;
/**
* Method analogous to CSSStyleDeclaration::GetPropertyValue,
* which obeys all the same restrictions.
*/
virtual nsresult GetPropertyValue(const nsCSSPropertyID aPropID,
nsACString& aValue);
/**
* Method analogous to CSSStyleDeclaration::SetProperty. This
* method does NOT allow setting a priority (the priority will
* always be set to default priority).
*/
virtual void SetPropertyValue(const nsCSSPropertyID aPropID,
const nsACString& aValue,
nsIPrincipal* aSubjectPrincipal,
mozilla::ErrorResult& aRv);
// Require subclasses to implement |GetParentRule|.
// NS_DECL_NSIDOMCSSSTYLEDECLARATION
void GetCssText(nsACString& aCssText) override;
void SetCssText(const nsACString& aCssText, nsIPrincipal* aSubjectPrincipal,
mozilla::ErrorResult& aRv) override;
NS_IMETHOD GetPropertyValue(const nsACString& propertyName,
nsACString& _retval) override;
void RemoveProperty(const nsACString& propertyName, nsACString& _retval,
mozilla::ErrorResult& aRv) override;
void GetPropertyPriority(const nsACString& propertyName,
nsACString& aPriority) override;
void SetProperty(const nsACString& propertyName, const nsACString& value,
const nsACString& priority, nsIPrincipal* aSubjectPrincipal,
mozilla::ErrorResult& aRv) override;
uint32_t Length() override;
// WebIDL interface for CSS2Properties
#define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) publicname_
#define CSS_PROP(id_, method_) \
void Get##method_(nsACString& aValue, mozilla::ErrorResult& rv) { \
rv = GetPropertyValue(eCSSProperty_##id_, aValue); \
} \
\
void Set##method_(const nsACString& aValue, nsIPrincipal* aSubjectPrincipal, \
mozilla::ErrorResult& aRv) { \
SetPropertyValue(eCSSProperty_##id_, aValue, aSubjectPrincipal, aRv); \
}
#define CSS_PROP_LIST_EXCLUDE_INTERNAL
#define CSS_PROP_LIST_EXCLUDE_NOT_IN_STYLE
#define CSS_PROP_LONGHAND(name_, id_, method_, ...) CSS_PROP(id_, method_)
#define CSS_PROP_SHORTHAND(name_, id_, method_, ...) CSS_PROP(id_, method_)
#define CSS_PROP_ALIAS(name_, aliasid_, id_, method_, ...) \
CSS_PROP(id_, method_)
#include "mozilla/ServoCSSPropList.h"
#undef CSS_PROP_ALIAS
#undef CSS_PROP_SHORTHAND
#undef CSS_PROP_LONGHAND
#undef CSS_PROP_LIST_EXCLUDE_INTERNAL
#undef CSS_PROP_LIST_EXCLUDE_NOT_IN_STYLE
#undef CSS_PROP
#undef CSS_PROP_PUBLIC_OR_PRIVATE
virtual void IndexedGetter(uint32_t aIndex, bool& aFound,
nsACString& aPropName) override;
JSObject* WrapObject(JSContext*, JS::Handle<JSObject*> aGivenProto) override;
// Information needed to parse a declaration for Servo side.
// Put this in public so other Servo parsing functions can reuse this.
struct MOZ_STACK_CLASS ParsingEnvironment {
RefPtr<mozilla::URLExtraData> mUrlExtraData;
nsCompatibility mCompatMode = eCompatibility_FullStandards;
mozilla::css::Loader* mLoader = nullptr;
mozilla::StyleCssRuleType mRuleType{1 /* Style */};
};
protected:
// The reason for calling GetOrCreateCSSDeclaration.
enum class Operation {
// We are calling GetOrCreateCSSDeclaration so that we can read from it.
// Does not allocate a new declaration if we don't have one yet; returns
// nullptr in this case.
Read,
// We are calling GetOrCreateCSSDeclaration so that we can set a property on
// it or re-parse the whole declaration. Allocates a new declaration if we
// don't have one yet. A nullptr return value indicates an error allocating
// the declaration.
Modify,
// We are calling GetOrCreateCSSDeclaration so that we can remove a property
// from it. Does not allocate a new declaration if we don't have one yet;
// returns nullptr in this case.
RemoveProperty,
};
// If aOperation is Modify, aCreated must be non-null and the call may set it
// to point to the newly created object.
virtual mozilla::DeclarationBlock* GetOrCreateCSSDeclaration(
Operation aOperation, mozilla::DeclarationBlock** aCreated) = 0;
virtual nsresult SetCSSDeclaration(
mozilla::DeclarationBlock* aDecl,
mozilla::MutationClosureData* aClosureData) = 0;
// Document that we must call BeginUpdate/EndUpdate on around the
// calls to SetCSSDeclaration and the style rule mutation that leads
// to it.
virtual mozilla::dom::Document* DocToUpdate() = 0;
// mUrlExtraData returns URL data for parsing url values in
// CSS. Returns nullptr on failure. If mUrlExtraData is nullptr,
// mCompatMode may not be set to anything meaningful.
// If aSubjectPrincipal is passed, it should be the subject principal of the
// scripted caller that initiated the parser.
virtual ParsingEnvironment GetParsingEnvironment(
nsIPrincipal* aSubjectPrincipal = nullptr) const = 0;
// An implementation for GetParsingEnvironment for callers wrapping a
// css::Rule.
//
// The RuleType argument is just to avoid a virtual call, since all callers
// know it statically. Should be equal to aRule->Type().
static ParsingEnvironment GetParsingEnvironmentForRule(
const mozilla::css::Rule* aRule, mozilla::StyleCssRuleType);
nsresult ParsePropertyValue(const nsCSSPropertyID aPropID,
const nsACString& aPropValue, bool aIsImportant,
nsIPrincipal* aSubjectPrincipal);
nsresult ParseCustomPropertyValue(const nsACString& aPropertyName,
const nsACString& aPropValue,
bool aIsImportant,
nsIPrincipal* aSubjectPrincipal);
void RemovePropertyInternal(nsCSSPropertyID aPropID,
mozilla::ErrorResult& aRv);
void RemovePropertyInternal(const nsACString& aPropert,
mozilla::ErrorResult& aRv);
virtual void GetPropertyChangeClosure(
mozilla::DeclarationBlockMutationClosure* aClosure,
mozilla::MutationClosureData* aClosureData) {}
protected:
virtual ~nsDOMCSSDeclaration();
private:
template <typename ServoFunc>
inline nsresult ModifyDeclaration(nsIPrincipal* aSubjectPrincipal,
mozilla::MutationClosureData* aClosureData,
ServoFunc aServoFunc);
};
#endif // nsDOMCSSDeclaration_h___
|
