mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-01 00:32:11 +00:00
69790bc62e
The inclusions were removed with the following very crude script and the
resulting breakage was fixed up by hand. The manual fixups did either
revert the changes done by the script, replace a generic header with a more
specific one or replace a header with a forward declaration.
find . -name "*.idl" | grep -v web-platform | grep -v third_party | while read path; do
interfaces=$(grep "^\(class\|interface\).*:.*" "$path" | cut -d' ' -f2)
if [ -n "$interfaces" ]; then
if [[ "$interfaces" == *$'\n'* ]]; then
regexp="\("
for i in $interfaces; do regexp="$regexp$i\|"; done
regexp="${regexp%%\\\|}\)"
else
regexp="$interfaces"
fi
interface=$(basename "$path")
rg -l "#include.*${interface%%.idl}.h" . | while read path2; do
hits=$(grep -v "#include.*${interface%%.idl}.h" "$path2" | grep -c "$regexp" )
if [ $hits -eq 0 ]; then
echo "Removing ${interface} from ${path2}"
grep -v "#include.*${interface%%.idl}.h" "$path2" > "$path2".tmp
mv -f "$path2".tmp "$path2"
fi
done
fi
done
Differential Revision: https://phabricator.services.mozilla.com/D55443
--HG--
extra : moz-landing-system : lando
397 lines
13 KiB
C++
397 lines
13 KiB
C++
/* -*- 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 */
|
|
|
|
#include "nsDOMCSSDeclaration.h"
|
|
|
|
#include "mozilla/DeclarationBlock.h"
|
|
#include "mozilla/StyleSheetInlines.h"
|
|
#include "mozilla/css/Rule.h"
|
|
#include "mozilla/dom/CSS2PropertiesBinding.h"
|
|
#include "mozilla/dom/MutationEventBinding.h"
|
|
#include "nsCSSProps.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "mozAutoDocUpdate.h"
|
|
#include "mozilla/dom/BindingUtils.h"
|
|
#include "nsQueryObject.h"
|
|
#include "mozilla/layers/ScrollLinkedEffectDetector.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
nsDOMCSSDeclaration::~nsDOMCSSDeclaration() = default;
|
|
|
|
/* virtual */
|
|
JSObject* nsDOMCSSDeclaration::WrapObject(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return CSS2Properties_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
NS_IMPL_QUERY_INTERFACE(nsDOMCSSDeclaration, nsICSSDeclaration)
|
|
|
|
nsresult nsDOMCSSDeclaration::GetPropertyValue(const nsCSSPropertyID aPropID,
|
|
nsAString& aValue) {
|
|
MOZ_ASSERT(aPropID != eCSSProperty_UNKNOWN,
|
|
"Should never pass eCSSProperty_UNKNOWN around");
|
|
|
|
aValue.Truncate();
|
|
if (DeclarationBlock* decl =
|
|
GetOrCreateCSSDeclaration(eOperation_Read, nullptr)) {
|
|
decl->GetPropertyValueByID(aPropID, aValue);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsDOMCSSDeclaration::SetPropertyValue(
|
|
const nsCSSPropertyID aPropID, const nsAString& aValue,
|
|
nsIPrincipal* aSubjectPrincipal) {
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
switch (aPropID) {
|
|
case eCSSProperty_background_position:
|
|
case eCSSProperty_background_position_x:
|
|
case eCSSProperty_background_position_y:
|
|
case eCSSProperty_transform:
|
|
case eCSSProperty_translate:
|
|
case eCSSProperty_rotate:
|
|
case eCSSProperty_scale:
|
|
case eCSSProperty_top:
|
|
case eCSSProperty_left:
|
|
case eCSSProperty_bottom:
|
|
case eCSSProperty_right:
|
|
case eCSSProperty_margin:
|
|
case eCSSProperty_margin_top:
|
|
case eCSSProperty_margin_left:
|
|
case eCSSProperty_margin_bottom:
|
|
case eCSSProperty_margin_right:
|
|
case eCSSProperty_margin_inline_start:
|
|
case eCSSProperty_margin_inline_end:
|
|
case eCSSProperty_margin_block_start:
|
|
case eCSSProperty_margin_block_end:
|
|
mozilla::layers::ScrollLinkedEffectDetector::PositioningPropertyMutated();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (aValue.IsEmpty()) {
|
|
// If the new value of the property is an empty string we remove the
|
|
// property.
|
|
return RemovePropertyInternal(aPropID);
|
|
}
|
|
|
|
return ParsePropertyValue(aPropID, aValue, false, aSubjectPrincipal);
|
|
}
|
|
|
|
void nsDOMCSSDeclaration::GetCssText(nsAString& aCssText) {
|
|
DeclarationBlock* decl = GetOrCreateCSSDeclaration(eOperation_Read, nullptr);
|
|
aCssText.Truncate();
|
|
|
|
if (decl) {
|
|
decl->ToString(aCssText);
|
|
}
|
|
}
|
|
|
|
void nsDOMCSSDeclaration::SetCssText(const nsAString& aCssText,
|
|
nsIPrincipal* aSubjectPrincipal,
|
|
ErrorResult& aRv) {
|
|
if (IsReadOnly()) {
|
|
return;
|
|
}
|
|
|
|
// We don't need to *do* anything with the old declaration, but we need
|
|
// to ensure that it exists, or else SetCSSDeclaration may crash.
|
|
RefPtr<DeclarationBlock> created;
|
|
DeclarationBlock* olddecl =
|
|
GetOrCreateCSSDeclaration(eOperation_Modify, getter_AddRefs(created));
|
|
if (!olddecl) {
|
|
aRv.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return;
|
|
}
|
|
|
|
// For nsDOMCSSAttributeDeclaration, SetCSSDeclaration will lead to
|
|
// Attribute setting code, which leads in turn to BeginUpdate. We
|
|
// need to start the update now so that the old rule doesn't get used
|
|
// between when we mutate the declaration and when we set the new
|
|
// rule (see stack in bug 209575).
|
|
mozAutoDocUpdate autoUpdate(DocToUpdate(), true);
|
|
DeclarationBlockMutationClosure closure = {};
|
|
MutationClosureData closureData;
|
|
GetPropertyChangeClosure(&closure, &closureData);
|
|
|
|
ParsingEnvironment servoEnv = GetParsingEnvironment(aSubjectPrincipal);
|
|
if (!servoEnv.mUrlExtraData) {
|
|
aRv.Throw(NS_ERROR_NOT_AVAILABLE);
|
|
return;
|
|
}
|
|
|
|
// Need to special case closure calling here, since parsing css text
|
|
// doesn't modify any existing declaration and that is why the callback isn't
|
|
// called implicitly.
|
|
if (closureData.mClosure) {
|
|
closureData.mClosure(&closureData);
|
|
}
|
|
|
|
RefPtr<DeclarationBlock> newdecl = DeclarationBlock::FromCssText(
|
|
aCssText, servoEnv.mUrlExtraData, servoEnv.mCompatMode, servoEnv.mLoader);
|
|
|
|
aRv = SetCSSDeclaration(newdecl, &closureData);
|
|
}
|
|
|
|
uint32_t nsDOMCSSDeclaration::Length() {
|
|
DeclarationBlock* decl = GetOrCreateCSSDeclaration(eOperation_Read, nullptr);
|
|
|
|
if (decl) {
|
|
return decl->Count();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void nsDOMCSSDeclaration::IndexedGetter(uint32_t aIndex, bool& aFound,
|
|
nsAString& aPropName) {
|
|
DeclarationBlock* decl = GetOrCreateCSSDeclaration(eOperation_Read, nullptr);
|
|
aFound = decl && decl->GetNthProperty(aIndex, aPropName);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDOMCSSDeclaration::GetPropertyValue(const nsAString& aPropertyName,
|
|
nsAString& aReturn) {
|
|
aReturn.Truncate();
|
|
if (DeclarationBlock* decl =
|
|
GetOrCreateCSSDeclaration(eOperation_Read, nullptr)) {
|
|
decl->GetPropertyValue(aPropertyName, aReturn);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsDOMCSSDeclaration::GetPropertyPriority(const nsAString& aPropertyName,
|
|
nsAString& aPriority) {
|
|
DeclarationBlock* decl = GetOrCreateCSSDeclaration(eOperation_Read, nullptr);
|
|
|
|
aPriority.Truncate();
|
|
if (decl && decl->GetPropertyIsImportant(aPropertyName)) {
|
|
aPriority.AssignLiteral("important");
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDOMCSSDeclaration::SetProperty(const nsAString& aPropertyName,
|
|
const nsAString& aValue,
|
|
const nsAString& aPriority,
|
|
nsIPrincipal* aSubjectPrincipal) {
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aValue.IsEmpty()) {
|
|
// If the new value of the property is an empty string we remove the
|
|
// property.
|
|
// XXX this ignores the priority string, should it?
|
|
return RemovePropertyInternal(aPropertyName);
|
|
}
|
|
|
|
// In the common (and fast) cases we can use the property id
|
|
nsCSSPropertyID propID = nsCSSProps::LookupProperty(aPropertyName);
|
|
if (propID == eCSSProperty_UNKNOWN) {
|
|
return NS_OK;
|
|
}
|
|
|
|
bool important;
|
|
if (aPriority.IsEmpty()) {
|
|
important = false;
|
|
} else if (aPriority.LowerCaseEqualsASCII("important")) {
|
|
important = true;
|
|
} else {
|
|
// XXX silent failure?
|
|
return NS_OK;
|
|
}
|
|
|
|
if (propID == eCSSPropertyExtra_variable) {
|
|
return ParseCustomPropertyValue(aPropertyName, aValue, important,
|
|
aSubjectPrincipal);
|
|
}
|
|
return ParsePropertyValue(propID, aValue, important, aSubjectPrincipal);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsDOMCSSDeclaration::RemoveProperty(const nsAString& aPropertyName,
|
|
nsAString& aReturn) {
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv = GetPropertyValue(aPropertyName, aReturn);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
return RemovePropertyInternal(aPropertyName);
|
|
}
|
|
|
|
/* static */ nsDOMCSSDeclaration::ParsingEnvironment
|
|
nsDOMCSSDeclaration::GetParsingEnvironmentForRule(const css::Rule* aRule) {
|
|
StyleSheet* sheet = aRule ? aRule->GetStyleSheet() : nullptr;
|
|
if (!sheet) {
|
|
return {nullptr, eCompatibility_FullStandards, nullptr};
|
|
}
|
|
|
|
if (Document* document = sheet->GetAssociatedDocument()) {
|
|
return {
|
|
sheet->URLData(),
|
|
document->GetCompatibilityMode(),
|
|
document->CSSLoader(),
|
|
};
|
|
}
|
|
|
|
return {
|
|
sheet->URLData(),
|
|
eCompatibility_FullStandards,
|
|
nullptr,
|
|
};
|
|
}
|
|
|
|
template <typename Func>
|
|
nsresult nsDOMCSSDeclaration::ModifyDeclaration(
|
|
nsIPrincipal* aSubjectPrincipal, MutationClosureData* aClosureData,
|
|
Func aFunc) {
|
|
RefPtr<DeclarationBlock> created;
|
|
DeclarationBlock* olddecl =
|
|
GetOrCreateCSSDeclaration(eOperation_Modify, getter_AddRefs(created));
|
|
if (!olddecl) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
// For nsDOMCSSAttributeDeclaration, SetCSSDeclaration will lead to
|
|
// Attribute setting code, which leads in turn to BeginUpdate. We
|
|
// need to start the update now so that the old rule doesn't get used
|
|
// between when we mutate the declaration and when we set the new
|
|
// rule (see stack in bug 209575).
|
|
mozAutoDocUpdate autoUpdate(DocToUpdate(), true);
|
|
RefPtr<DeclarationBlock> decl = olddecl->EnsureMutable();
|
|
|
|
bool changed;
|
|
ParsingEnvironment servoEnv = GetParsingEnvironment(aSubjectPrincipal);
|
|
if (!servoEnv.mUrlExtraData) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
changed = aFunc(decl, servoEnv);
|
|
|
|
if (!changed) {
|
|
// Parsing failed -- but we don't throw an exception for that.
|
|
return NS_OK;
|
|
}
|
|
|
|
return SetCSSDeclaration(decl, aClosureData);
|
|
}
|
|
|
|
nsresult nsDOMCSSDeclaration::ParsePropertyValue(
|
|
const nsCSSPropertyID aPropID, const nsAString& aPropValue,
|
|
bool aIsImportant, nsIPrincipal* aSubjectPrincipal) {
|
|
AUTO_PROFILER_LABEL_CATEGORY_PAIR(LAYOUT_CSSParsing);
|
|
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
DeclarationBlockMutationClosure closure = {};
|
|
MutationClosureData closureData;
|
|
GetPropertyChangeClosure(&closure, &closureData);
|
|
|
|
return ModifyDeclaration(
|
|
aSubjectPrincipal, &closureData,
|
|
[&](DeclarationBlock* decl, ParsingEnvironment& env) {
|
|
NS_ConvertUTF16toUTF8 value(aPropValue);
|
|
return Servo_DeclarationBlock_SetPropertyById(
|
|
decl->Raw(), aPropID, &value, aIsImportant, env.mUrlExtraData,
|
|
ParsingMode::Default, env.mCompatMode, env.mLoader, closure);
|
|
});
|
|
}
|
|
|
|
nsresult nsDOMCSSDeclaration::ParseCustomPropertyValue(
|
|
const nsAString& aPropertyName, const nsAString& aPropValue,
|
|
bool aIsImportant, nsIPrincipal* aSubjectPrincipal) {
|
|
MOZ_ASSERT(nsCSSProps::IsCustomPropertyName(aPropertyName));
|
|
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
DeclarationBlockMutationClosure closure = {};
|
|
MutationClosureData closureData;
|
|
GetPropertyChangeClosure(&closure, &closureData);
|
|
|
|
return ModifyDeclaration(
|
|
aSubjectPrincipal, &closureData,
|
|
[&](DeclarationBlock* decl, ParsingEnvironment& env) {
|
|
NS_ConvertUTF16toUTF8 property(aPropertyName);
|
|
NS_ConvertUTF16toUTF8 value(aPropValue);
|
|
return Servo_DeclarationBlock_SetProperty(
|
|
decl->Raw(), &property, &value, aIsImportant, env.mUrlExtraData,
|
|
ParsingMode::Default, env.mCompatMode, env.mLoader, closure);
|
|
});
|
|
}
|
|
|
|
nsresult nsDOMCSSDeclaration::RemovePropertyInternal(nsCSSPropertyID aPropID) {
|
|
DeclarationBlock* olddecl =
|
|
GetOrCreateCSSDeclaration(eOperation_RemoveProperty, nullptr);
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!olddecl) {
|
|
return NS_OK; // no decl, so nothing to remove
|
|
}
|
|
|
|
// For nsDOMCSSAttributeDeclaration, SetCSSDeclaration will lead to
|
|
// Attribute setting code, which leads in turn to BeginUpdate. We
|
|
// need to start the update now so that the old rule doesn't get used
|
|
// between when we mutate the declaration and when we set the new
|
|
// rule (see stack in bug 209575).
|
|
mozAutoDocUpdate autoUpdate(DocToUpdate(), true);
|
|
|
|
DeclarationBlockMutationClosure closure = {};
|
|
MutationClosureData closureData;
|
|
GetPropertyChangeClosure(&closure, &closureData);
|
|
|
|
RefPtr<DeclarationBlock> decl = olddecl->EnsureMutable();
|
|
if (!decl->RemovePropertyByID(aPropID, closure)) {
|
|
return NS_OK;
|
|
}
|
|
return SetCSSDeclaration(decl, &closureData);
|
|
}
|
|
|
|
nsresult nsDOMCSSDeclaration::RemovePropertyInternal(
|
|
const nsAString& aPropertyName) {
|
|
if (IsReadOnly()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
DeclarationBlock* olddecl =
|
|
GetOrCreateCSSDeclaration(eOperation_RemoveProperty, nullptr);
|
|
if (!olddecl) {
|
|
return NS_OK; // no decl, so nothing to remove
|
|
}
|
|
|
|
// For nsDOMCSSAttributeDeclaration, SetCSSDeclaration will lead to
|
|
// Attribute setting code, which leads in turn to BeginUpdate. We
|
|
// need to start the update now so that the old rule doesn't get used
|
|
// between when we mutate the declaration and when we set the new
|
|
// rule (see stack in bug 209575).
|
|
mozAutoDocUpdate autoUpdate(DocToUpdate(), true);
|
|
|
|
DeclarationBlockMutationClosure closure = {};
|
|
MutationClosureData closureData;
|
|
GetPropertyChangeClosure(&closure, &closureData);
|
|
|
|
RefPtr<DeclarationBlock> decl = olddecl->EnsureMutable();
|
|
if (!decl->RemoveProperty(aPropertyName, closure)) {
|
|
return NS_OK;
|
|
}
|
|
return SetCSSDeclaration(decl, &closureData);
|
|
}
|