Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 */
* methods for dealing with CSS properties and tables of the keyword
* values they accept
#ifndef nsCSSProps_h___
#define nsCSSProps_h___
#include <limits>
#include <ostream>
#include <type_traits>
#include "nsString.h"
#include "nsCSSPropertyID.h"
#include "nsStyleStructFwd.h"
#include "mozilla/UseCounter.h"
#include "mozilla/CSSEnabledState.h"
#include "mozilla/CSSPropFlags.h"
#include "mozilla/EnumTypeTraits.h"
#include "mozilla/Preferences.h"
#include "mozilla/gfx/gfxVarReceiver.h"
#include "nsXULAppAPI.h"
// Length of the "--" prefix on custom names (such as custom property names,
// and, in the future, custom media query names).
namespace mozilla {
class ComputedStyle;
extern "C" {
nsCSSPropertyID Servo_ResolveLogicalProperty(nsCSSPropertyID,
const mozilla::ComputedStyle*);
nsCSSPropertyID Servo_Property_LookupEnabledForAllContent(const nsACString*);
const uint8_t* Servo_Property_GetName(nsCSSPropertyID, uint32_t* aLength);
class nsCSSProps {
typedef mozilla::CSSEnabledState EnabledState;
typedef mozilla::CSSPropFlags Flags;
static void AddRefTable(void);
static void ReleaseTable(void);
// Looks up the property with name aProperty and returns its corresponding
// nsCSSPropertyID value. If aProperty is the name of a custom property,
// then eCSSPropertyExtra_variable will be returned.
// This only returns properties enabled for all content, and resolves aliases
// to return the aliased property.
static nsCSSPropertyID LookupProperty(const nsACString& aProperty) {
return Servo_Property_LookupEnabledForAllContent(&aProperty);
// As above, but looked up using a property's IDL name.
// eCSSPropertyExtra_variable won't be returned from this method.
static nsCSSPropertyID LookupPropertyByIDLName(
const nsACString& aPropertyIDLName, EnabledState aEnabled);
// Returns whether aProperty is a custom property name, i.e. begins with
// "--". This assumes that the CSS Variables pref has been enabled.
static bool IsCustomPropertyName(const nsACString& aProperty);
static bool IsShorthand(nsCSSPropertyID aProperty) {
MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
"out of range");
return (aProperty >= eCSSProperty_COUNT_no_shorthands);
// Same but for @font-face descriptors
static nsCSSFontDesc LookupFontDesc(const nsACString& aProperty);
// The relevant invariants are asserted in Document.cpp
static mozilla::UseCounter UseCounterFor(nsCSSPropertyID aProperty) {
MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_with_aliases,
"out of range");
return mozilla::UseCounter(size_t(mozilla::eUseCounter_FirstCSSProperty) +
// Given a property enum, get the string value
// This string is static.
static const nsDependentCSubstring GetStringValue(nsCSSPropertyID aProperty) {
uint32_t len;
const uint8_t* chars = Servo_Property_GetName(aProperty, &len);
return nsDependentCSubstring(reinterpret_cast<const char*>(chars), len);
static const nsCString& GetStringValue(nsCSSFontDesc aFontDesc);
static const nsCString& GetStringValue(nsCSSCounterDesc aCounterDesc);
static bool PropHasFlags(nsCSSPropertyID aProperty, Flags aFlags);
static nsCSSPropertyID Physicalize(nsCSSPropertyID aProperty,
const mozilla::ComputedStyle& aStyle) {
if (PropHasFlags(aProperty, Flags::IsLogical)) {
return Servo_ResolveLogicalProperty(aProperty, &aStyle);
return aProperty;
// A table for shorthand properties. The appropriate index is the
// property ID minus eCSSProperty_COUNT_no_shorthands.
static const nsCSSPropertyID* const
kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands];
* Returns true if the backdrop-filter pref and the gfx blocklist are enabled.
static bool IsBackdropFilterAvailable(JSContext*, JSObject*) {
return IsEnabled(eCSSProperty_backdrop_filter, EnabledState::ForAllContent);
* Recoumputes the enabled state of a pref. If aPrefName is nullptr,
* recomputes the state of all prefs in gPropertyEnabled.
* aClosure is the pref callback closure data, which is not used.
static void RecomputeEnabledState(const char* aPrefName,
void* aClosure = nullptr);
* Retrieve a singleton receiver to register with gfxVars
static mozilla::gfx::gfxVarReceiver& GfxVarReceiver();
static const nsCSSPropertyID* SubpropertyEntryFor(nsCSSPropertyID aProperty) {
MOZ_ASSERT(eCSSProperty_COUNT_no_shorthands <= aProperty &&
aProperty < eCSSProperty_COUNT,
"out of range");
return kSubpropertyTable[aProperty - eCSSProperty_COUNT_no_shorthands];
static bool gPropertyEnabled[eCSSProperty_COUNT_with_aliases];
// Defined in the generated
static const char* const kIDLNameTable[eCSSProperty_COUNT];
* Returns the IDL name of the specified property, which must be a
* longhand, logical or shorthand property. The IDL name is the property
* name with any hyphen-lowercase character pairs replaced by an
* uppercase character:
* As a special case, the string "cssFloat" is returned for the float
* property. nullptr is returned for internal properties.
static const char* PropertyIDLName(nsCSSPropertyID aProperty) {
MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
"out of range");
return kIDLNameTable[aProperty];
static const int32_t kIDLNameSortPositionTable[eCSSProperty_COUNT];
* Returns the position of the specified property in a list of all
* properties sorted by their IDL name.
static int32_t PropertyIDLNameSortPosition(nsCSSPropertyID aProperty) {
MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
"out of range");
return kIDLNameSortPositionTable[aProperty];
static bool IsEnabled(nsCSSPropertyID aProperty, EnabledState aEnabled) {
MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_with_aliases,
"out of range");
// In the child process, assert that we're not trying to parse stylesheets
// before we've gotten all our prefs.
if (gPropertyEnabled[aProperty]) {
return true;
if (aEnabled == EnabledState::IgnoreEnabledState) {
return true;
if ((aEnabled & EnabledState::InUASheets) &&
PropHasFlags(aProperty, Flags::EnabledInUASheets)) {
return true;
if ((aEnabled & EnabledState::InChrome) &&
PropHasFlags(aProperty, Flags::EnabledInChrome)) {
return true;
return false;
struct PropertyPref {
nsCSSPropertyID mPropID;
const char* mPref;
static const PropertyPref kPropertyPrefTable[];
// Storing the enabledstate_ value in an nsCSSPropertyID variable is a small
// hack to avoid needing a separate variable declaration for its real type
// (CSSEnabledState), which would then require using a block and
// therefore a pair of macros by consumers for the start and end of the loop.
#define CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(it_, prop_, enabledstate_) \
for (const nsCSSPropertyID * \
it_ = nsCSSProps::SubpropertyEntryFor(prop_), \
es_ = (nsCSSPropertyID)((enabledstate_) | CSSEnabledState(0)); \
*it_ != eCSSProperty_UNKNOWN; ++it_) \
if (nsCSSProps::IsEnabled(*it_, (mozilla::CSSEnabledState)es_))
// MOZ_DBG support for nsCSSPropertyID
inline std::ostream& operator<<(std::ostream& aOut, nsCSSPropertyID aProperty) {
return aOut << nsCSSProps::GetStringValue(aProperty);
#endif /* nsCSSProps_h___ */