Backed out 4 changesets (bug 1456364) for build bustages at /builds/worker/workspace/build/src/obj-firefox/dist/include/mozilla/dom/AnimationEffectReadOnlyBinding.h:35 on a CLOSED TREE
authorAndreea Pavel <apavel@mozilla.com>
Thu, 26 Apr 2018 08:27:45 +0300
changeset 415707 2146e75c9861a6096655a037b1ccd70aefe7b70e
parent 415706 f1618a16788385f61267bf584d702e7db13c1b9a
child 415708 ff08a042faec4233facf5b879be7d2a95acd08c9
push id33905
push userapavel@mozilla.com
push dateThu, 26 Apr 2018 13:45:18 +0000
treeherdermozilla-central@0be8ef04ed89 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1456364
milestone61.0a1
backs out020151240bb8d98378faea9b34e9576e495d3175
bc0aa5224d91b0187519a457b1b4bef412ef6369
d919bbe7440cb26af740935881961b3baa506b19
ab1472823e8a2932c504aec75081f9bbf5276246
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 4 changesets (bug 1456364) for build bustages at /builds/worker/workspace/build/src/obj-firefox/dist/include/mozilla/dom/AnimationEffectReadOnlyBinding.h:35 on a CLOSED TREE Backed out changeset 020151240bb8 (bug 1456364) Backed out changeset bc0aa5224d91 (bug 1456364) Backed out changeset d919bbe7440c (bug 1456364) Backed out changeset ab1472823e8a (bug 1456364)
devtools/shared/css/generated/mach_commands.py
dom/animation/EffectCompositor.cpp
dom/animation/KeyframeEffectReadOnly.cpp
dom/base/nsDocument.cpp
dom/bindings/GenerateCSS2PropertiesWebIDL.py
dom/html/HTMLHRElement.cpp
layout/base/nsRefreshDriver.h
layout/inspector/InspectorUtils.cpp
layout/painting/nsDisplayList.cpp
layout/style/CSSPropFlags.h
layout/style/GenerateCSSPropsGenerated.py
layout/style/GenerateServoCSSPropList.py
layout/style/GenericSpecifiedValues.h
layout/style/LayerAnimationInfo.cpp
layout/style/ServoCSSPropList.mako.py
layout/style/StyleAnimationValue.h
layout/style/moz.build
layout/style/nsCSSPropList.h
layout/style/nsCSSProps.cpp
layout/style/nsCSSProps.h
layout/style/nsCSSValue.h
layout/style/nsComputedDOMStyle.cpp
layout/style/nsTransitionManager.cpp
--- a/devtools/shared/css/generated/mach_commands.py
+++ b/devtools/shared/css/generated/mach_commands.py
@@ -56,17 +56,17 @@ class MachCommands(MachCommandBase):
         with open(dataPath, "r") as f:
             data = eval(f.read())
 
         # Map this list
         # (name, prop, id, flags, pref, proptype) => (name, pref)
         preferences = [
             (name, pref)
             for name, prop, id, flags, pref, proptype in data
-            if 'CSSPropFlags::Internal' not in flags and pref]
+            if 'CSS_PROPERTY_INTERNAL' not in flags and pref]
 
         return preferences
 
     def get_properties_db_from_xpcshell(self):
         """Generate the static css properties db for devtools from an xpcshell script."""
         build = MozbuildObject.from_environment()
 
         # Get the paths
--- a/dom/animation/EffectCompositor.cpp
+++ b/dom/animation/EffectCompositor.cpp
@@ -604,17 +604,17 @@ EffectCompositor::GetOverriddenPropertie
   }
 
   AutoTArray<nsCSSPropertyID, LayerAnimationInfo::kRecords> propertiesToTrack;
   {
     nsCSSPropertyIDSet propertiesToTrackAsSet;
     for (KeyframeEffectReadOnly* effect : aEffectSet) {
       for (const AnimationProperty& property : effect->Properties()) {
         if (nsCSSProps::PropHasFlags(property.mProperty,
-                                     CSSPropFlags::CanAnimateOnCompositor) &&
+                                     CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR) &&
             !propertiesToTrackAsSet.HasProperty(property.mProperty)) {
           propertiesToTrackAsSet.AddProperty(property.mProperty);
           propertiesToTrack.AppendElement(property.mProperty);
         }
       }
       // Skip iterating over the rest of the effects if we've already
       // found all the compositor-animatable properties.
       if (propertiesToTrack.Length() == LayerAnimationInfo::kRecords) {
--- a/dom/animation/KeyframeEffectReadOnly.cpp
+++ b/dom/animation/KeyframeEffectReadOnly.cpp
@@ -494,17 +494,17 @@ KeyframeEffectReadOnly::IsRunningOnCompo
   return false;
 }
 
 void
 KeyframeEffectReadOnly::SetIsRunningOnCompositor(nsCSSPropertyID aProperty,
                                                  bool aIsRunning)
 {
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
-                                      CSSPropFlags::CanAnimateOnCompositor),
+                                      CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "Property being animated on compositor is a recognized "
              "compositor-animatable property");
   for (AnimationProperty& property : mProperties) {
     if (property.mProperty == aProperty) {
       property.mIsRunningOnCompositor = aIsRunning;
       // We currently only set a performance warning message when animations
       // cannot be run on the compositor, so if this animation is running
       // on the compositor we don't need a message.
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -10,17 +10,16 @@
 
 #include "AudioChannelService.h"
 #include "nsDocument.h"
 #include "nsIDocumentInlines.h"
 #include "mozilla/AnimationComparator.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/BinarySearch.h"
-#include "mozilla/CSSEnabledState.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/EffectSet.h"
 #include "mozilla/EnumSet.h"
 #include "mozilla/IntegerRange.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Likely.h"
 #include "mozilla/PresShell.h"
 #include "mozilla/URLExtraData.h"
@@ -5740,17 +5739,17 @@ GetPseudoElementType(const nsString& aSt
 {
   MOZ_ASSERT(!aString.IsEmpty(), "GetPseudoElementType aString should be non-null");
   if (aString.Length() <= 2 || aString[0] != ':' || aString[1] != ':') {
     aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
     return CSSPseudoElementType::NotPseudo;
   }
   RefPtr<nsAtom> pseudo = NS_Atomize(Substring(aString, 1));
   return nsCSSPseudoElements::GetPseudoType(pseudo,
-      CSSEnabledState::eInUASheets);
+      nsCSSProps::EnabledState::eInUASheets);
 }
 
 already_AddRefed<Element>
 nsIDocument::CreateElement(const nsAString& aTagName,
                            const ElementCreationOptionsOrString& aOptions,
                            ErrorResult& rv)
 {
   rv = nsContentUtils::CheckQName(aTagName, false);
--- a/dom/bindings/GenerateCSS2PropertiesWebIDL.py
+++ b/dom/bindings/GenerateCSS2PropertiesWebIDL.py
@@ -12,17 +12,17 @@ import argparse
 def generateLine(propName, extendedAttrs):
     return "  [%s] attribute DOMString %s;\n" % (", ".join(extendedAttrs),
                                                  propName)
 def generate(output, idlFilename, dataFile):
     with open(dataFile, "r") as f:
         propList = eval(f.read())
     props = ""
     for name, prop, id, flags, pref, proptype in propList:
-        if "CSSPropFlags::Internal" in flags:
+        if "CSS_PROPERTY_INTERNAL" in flags:
             continue
         # Unfortunately, even some of the getters here are fallible
         # (e.g. on nsComputedDOMStyle).
         extendedAttrs = ["CEReactions", "Throws", "TreatNullAs=EmptyString",
                          "SetterNeedsSubjectPrincipal=NonSystem"]
         if pref is not "":
             extendedAttrs.append('Pref="%s"' % pref)
 
--- a/dom/html/HTMLHRElement.cpp
+++ b/dom/html/HTMLHRElement.cpp
@@ -2,18 +2,16 @@
 /* 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/. */
 
 #include "mozilla/dom/HTMLHRElement.h"
 #include "mozilla/dom/HTMLHRElementBinding.h"
 
-#include "nsCSSProps.h"
-
 NS_IMPL_NS_NEW_HTML_ELEMENT(HR)
 
 namespace mozilla {
 namespace dom {
 
 HTMLHRElement::HTMLHRElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
   : nsGenericHTMLElement(aNodeInfo)
 {
--- a/layout/base/nsRefreshDriver.h
+++ b/layout/base/nsRefreshDriver.h
@@ -17,29 +17,29 @@
 #include "mozilla/Vector.h"
 #include "mozilla/WeakPtr.h"
 #include "nsTObserverArray.h"
 #include "nsTArray.h"
 #include "nsTHashtable.h"
 #include "nsTObserverArray.h"
 #include "nsClassHashtable.h"
 #include "nsHashKeys.h"
+#include "mozilla/AnimationEventDispatcher.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/layers/TransactionIdAllocator.h"
 
 class nsPresContext;
 class nsIPresShell;
 class nsIDocument;
 class imgIRequest;
 class nsINode;
 class nsIRunnable;
 
 namespace mozilla {
-class AnimationEventDispatcher;
 class RefreshDriverTimer;
 class Runnable;
 
 namespace layout {
 class VsyncChild;
 } // namespace layout
 
 namespace dom {
--- a/layout/inspector/InspectorUtils.cpp
+++ b/layout/inspector/InspectorUtils.cpp
@@ -377,18 +377,18 @@ InspectorUtils::GetCSSPropertyNames(Glob
     if (nsCSSProps::IsEnabled(cssProp, enabledState)) {
       nsDependentCString name(kCSSRawProperties[prop]);
       aResult.AppendElement(NS_ConvertASCIItoUTF16(name));
     }
   };
 
   uint32_t prop = 0;
   for ( ; prop < eCSSProperty_COUNT_no_shorthands; ++prop) {
-    if (!nsCSSProps::PropHasFlags(nsCSSPropertyID(prop),
-                                  CSSPropFlags::Inaccessible)) {
+    if (nsCSSProps::PropertyParseType(nsCSSPropertyID(prop)) !=
+        CSS_PROPERTY_PARSE_INACCESSIBLE) {
       appendProperty(prop);
     }
   }
 
   if (aOptions.mIncludeShorthands) {
     for ( ; prop < eCSSProperty_COUNT; ++prop) {
       appendProperty(prop);
     }
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -676,17 +676,17 @@ AddAnimationsForProperty(nsIFrame* aFram
     data = TransformData(origin, offsetToTransformOrigin,
                          bounds, devPixelsToAppUnits,
                          scaleX, scaleY, hasPerspectiveParent);
   } else if (aProperty == eCSSProperty_opacity) {
     data = null_t();
   }
 
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
-                                      CSSPropFlags::CanAnimateOnCompositor),
+                                      CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "inconsistent property flags");
 
   // Add from first to last (since last overrides)
   for (size_t animIdx = 0; animIdx < compositorAnimations.Length(); animIdx++) {
     dom::Animation* anim = compositorAnimations[animIdx];
     if (!anim->IsRelevant()) {
       continue;
     }
@@ -809,17 +809,17 @@ GenerateAndPushTextMask(nsIFrame* aFrame
 /* static */ void
 nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(Layer* aLayer,
                                                          nsDisplayListBuilder* aBuilder,
                                                          nsDisplayItem* aItem,
                                                          nsIFrame* aFrame,
                                                          nsCSSPropertyID aProperty)
 {
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
-                                      CSSPropFlags::CanAnimateOnCompositor),
+                                      CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "inconsistent property flags");
 
   // This function can be called in two ways:  from
   // nsDisplay*::BuildLayer while constructing a layer (with all
   // pointers non-null), or from RestyleManager's handling of
   // UpdateOpacityLayer/UpdateTransformLayer hints.
   MOZ_ASSERT(!aBuilder == !aItem,
              "should only be called in two configurations, with both "
deleted file mode 100644
--- a/layout/style/CSSPropFlags.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* -*- 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/. */
-
-#ifndef mozilla_CSSPropFlags_h
-#define mozilla_CSSPropFlags_h
-
-#include "mozilla/TypedEnumBits.h"
-
-namespace mozilla {
-
-enum class CSSPropFlags : uint8_t
-{
-  // This property is not parsed. It is only there for internal use like
-  // attribute mapping.
-  Inaccessible = 1 << 0,
-
-  // This property's getComputedStyle implementation requires layout to
-  // be flushed.
-  GetCSNeedsLayoutFlush = 1 << 1,
-
-  // The following two flags along with the pref defines where the this
-  // property can be used:
-  // * If none of the two flags is presented, the pref completely controls
-  //   the availability of this property. And in that case, if it has no
-  //   pref, this property is usable everywhere.
-  // * If any of the flags is set, this property is always enabled in the
-  //   specific contexts regardless of the value of the pref. If there is
-  //   no pref for this property at all in this case, it is an internal-
-  //   only property, which cannot be used anywhere else, and should be
-  //   wrapped in "#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL".
-  // Note that, these flags have no effect on the use of aliases of this
-  // property.
-  // Furthermore, for the purposes of animation (including triggering
-  // transitions) these flags are ignored. That is, if the property is disabled
-  // by a pref, we will *not* run animations or transitions on it even in
-  // UA sheets or chrome.
-  EnabledInUASheets = 1 << 2,
-  EnabledInChrome = 1 << 3,
-  EnabledInUASheetsAndChrome = EnabledInUASheets | EnabledInChrome,
-  EnabledMask = EnabledInUASheetsAndChrome,
-
-  // This property can be animated on the compositor.
-  CanAnimateOnCompositor = 1 << 4,
-
-  // This property is an internal property that is not represented in
-  // the DOM. Properties with this flag are defined in an #ifndef
-  // CSS_PROP_LIST_EXCLUDE_INTERNAL section.
-  Internal = 1 << 5,
-};
-
-MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(CSSPropFlags)
-
-} // namespace mozilla
-
-#endif // mozilla_CSSPropFlags_h
--- a/layout/style/GenerateCSSPropsGenerated.py
+++ b/layout/style/GenerateCSSPropsGenerated.py
@@ -23,17 +23,17 @@ def get_properties(dataFile):
 
     properties = sorted(properties, cmp=property_compare)
 
     for i, p in enumerate(properties):
         p["index"] = i
 
     # Record each property's IDL name.
     for p in properties:
-        if "CSSPropFlags::Internal" in p["flags"]:
+        if "CSS_PROPERTY_INTERNAL" in p["flags"]:
             p["idlname"] = None
         else:
             idl_name = p["prop"]
             if not idl_name.startswith("Moz"):
                 idl_name = idl_name[0].lower() + idl_name[1:]
             p["idlname"] = idl_name
 
     return properties
--- a/layout/style/GenerateServoCSSPropList.py
+++ b/layout/style/GenerateServoCSSPropList.py
@@ -64,29 +64,29 @@ def generate_header(output, data):
 """)
 
     MACRO_NAMES = {
         "longhand": "CSS_PROP_LONGHAND",
         "shorthand": "CSS_PROP_SHORTHAND",
         "alias": "CSS_PROP_ALIAS",
     }
     for name, method, id, flags, pref, proptype in data:
-        is_internal = "CSSPropFlags::Internal" in flags
+        is_internal = "CSS_PROPERTY_INTERNAL" in flags
         pref = '"' + pref + '"'
         if proptype == "alias":
             params = [name, id[0], id[1], method, pref]
         else:
             if method == "CssFloat":
                 method = "CSS_PROP_PUBLIC_OR_PRIVATE(CssFloat, Float)"
             elif method.startswith("Moz"):
                 method = "CSS_PROP_DOMPROP_PREFIXED({})".format(method[3:])
             if flags:
                 flags = " | ".join(flags)
             else:
-                flags = "CSSPropFlags(0)"
+                flags = "0"
             params = [name, id, method, flags, pref]
 
         if is_internal:
             output.write("#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL\n")
         output.write("{}({})\n".format(MACRO_NAMES[proptype], ", ".join(params)))
         if is_internal:
             output.write("#endif\n")
 
--- a/layout/style/GenericSpecifiedValues.h
+++ b/layout/style/GenericSpecifiedValues.h
@@ -10,17 +10,17 @@
  * code generic over style backends.
  */
 
 #ifndef mozilla_GenericSpecifiedValues_h
 #define mozilla_GenericSpecifiedValues_h
 
 #include "mozilla/ServoUtils.h"
 #include "mozilla/FontPropertyTypes.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProps.h"
 #include "nsCSSValue.h"
 #include "nsColor.h"
 
 class nsAttrValue;
 
 namespace mozilla {
 
 class ServoSpecifiedValues;
--- a/layout/style/LayerAnimationInfo.cpp
+++ b/layout/style/LayerAnimationInfo.cpp
@@ -19,36 +19,36 @@ namespace mozilla {
       nsChangeHint_UpdateOpacityLayer } };
 
 #ifdef DEBUG
 /* static */ void
 LayerAnimationInfo::Initialize()
 {
   for (const Record& record : sRecords) {
     MOZ_ASSERT(nsCSSProps::PropHasFlags(record.mProperty,
-                                        CSSPropFlags::CanAnimateOnCompositor),
+                                        CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
                "CSS property with entry in LayerAnimation::sRecords does not "
-               "have the CSSPropFlags::CanAnimateOnCompositor flag");
+               "have the CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR flag");
   }
 
   // Check that every property with the flag for animating on the
   // compositor has an entry in LayerAnimationInfo::sRecords.
   for (nsCSSPropertyID prop = nsCSSPropertyID(0);
        prop < eCSSProperty_COUNT;
        prop = nsCSSPropertyID(prop + 1)) {
     if (nsCSSProps::PropHasFlags(prop,
-                                 CSSPropFlags::CanAnimateOnCompositor)) {
+                                 CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR)) {
       bool found = false;
       for (const Record& record : sRecords) {
         if (record.mProperty == prop) {
           found = true;
           break;
         }
       }
       MOZ_ASSERT(found,
-                 "CSS property with the CSSPropFlags::CanAnimateOnCompositor "
+                 "CSS property with the CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR "
                  "flag does not have an entry in LayerAnimationInfo::sRecords");
     }
   }
 }
 #endif
 
 } // namespace mozilla
--- a/layout/style/ServoCSSPropList.mako.py
+++ b/layout/style/ServoCSSPropList.mako.py
@@ -25,28 +25,28 @@ def is_internal(prop):
         "-moz-window-transform",
         "-moz-window-transform-origin",
     ]
     return prop.name in OTHER_INTERNALS
 
 def flags(prop):
     result = []
     if prop.explicitly_enabled_in_chrome():
-        result.append("EnabledInUASheetsAndChrome")
+        result.append("CSS_PROPERTY_ENABLED_IN_UA_SHEETS_AND_CHROME")
     elif prop.explicitly_enabled_in_ua_sheets():
-        result.append("EnabledInUASheets")
+        result.append("CSS_PROPERTY_ENABLED_IN_UA_SHEETS")
     if is_internal(prop):
-        result.append("Internal")
+        result.append("CSS_PROPERTY_INTERNAL")
     if prop.enabled_in == "":
-        result.append("Inaccessible")
+        result.append("CSS_PROPERTY_PARSE_INACCESSIBLE")
     if "GETCS_NEEDS_LAYOUT_FLUSH" in prop.flags:
-        result.append("GetCSNeedsLayoutFlush")
+        result.append("CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH")
     if "CAN_ANIMATE_ON_COMPOSITOR" in prop.flags:
-        result.append("CanAnimateOnCompositor")
-    return ", ".join('"CSSPropFlags::{}"'.format(flag) for flag in result)
+        result.append("CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR")
+    return ", ".join('"{}"'.format(flag) for flag in result)
 
 def pref(prop):
     if prop.gecko_pref:
         return '"' + prop.gecko_pref + '"'
     return '""'
 %>
 
 [
--- a/layout/style/StyleAnimationValue.h
+++ b/layout/style/StyleAnimationValue.h
@@ -12,17 +12,17 @@
 #include "mozilla/gfx/MatrixFwd.h"
 #include "mozilla/gfx/Point.h"
 #include "mozilla/ServoBindingTypes.h"
 #include "mozilla/UniquePtr.h"
 #include "nsStringFwd.h"
 #include "nsStringBuffer.h"
 #include "nsCoord.h"
 #include "nsColor.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProps.h"
 #include "nsCSSValue.h"
 #include "nsStyleCoord.h"
 #include "nsStyleTransformMatrix.h"
 
 class nsIFrame;
 class gfx3DMatrix;
 
 namespace mozilla {
--- a/layout/style/moz.build
+++ b/layout/style/moz.build
@@ -65,17 +65,16 @@ EXPORTS += [
 EXPORTS.mozilla += [
     '!ServoCSSPropList.h',
     'AnimationCollection.h',
     'BindingStyleRule.h',
     'CachedInheritingStyles.h',
     'ComputedStyle.h',
     'ComputedStyleInlines.h',
     'CSSEnabledState.h',
-    'CSSPropFlags.h',
     'DeclarationBlock.h',
     'DeclarationBlockInlines.h',
     'DocumentStyleRootIterator.h',
     'GenericSpecifiedValues.h',
     'GenericSpecifiedValuesInlines.h',
     'LayerAnimationInfo.h',
     'MediaFeatureChange.h',
     'PostTraversalTask.h',
--- a/layout/style/nsCSSPropList.h
+++ b/layout/style/nsCSSPropList.h
@@ -35,52 +35,54 @@
   InterCaps and all hyphens ('-') must be removed.  Callers using this
   parameter must also define the CSS_PROP_PUBLIC_OR_PRIVATE(publicname_,
   privatename_) macro to yield either publicname_ or privatename_.
   The names differ in that publicname_ has Moz prefixes where they are
   used, and also in CssFloat vs. Float.  The caller's choice depends on
   whether the use is for internal use such as eCSSProperty_* or
   nsRuleData::ValueFor* or external use such as exposing DOM properties.
 
+  -. 'flags', a bitfield containing CSS_PROPERTY_* flags.
+
   -. 'pref' is the name of a pref that controls whether the property
   is enabled.  The property is enabled if 'pref' is an empty string,
   or if the boolean property whose name is 'pref' is set to true.
 
   -. 'parsevariant', to be passed to ParseVariant in the parser.
 
   -. 'kwtable', which is either nullptr or the name of the appropriate
   keyword table member of class nsCSSProps, for use in
   nsCSSProps::LookupPropertyValue.
 
   -. 'animtype_' gives the animation type (see nsStyleAnimType) of this
   property.
 
-  CSS_PROP_SHORTHAND only takes 1-4.
+  CSS_PROP_SHORTHAND only takes 1-5.
 
  ******/
 
 
 /*************************************************************************/
 
 
 // All includers must explicitly define CSS_PROP_SHORTHAND if they
 // want it.
 #ifndef CSS_PROP_SHORTHAND
-#define CSS_PROP_SHORTHAND(name_, id_, method_, pref_) /* nothing */
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) /* nothing */
 #define DEFINED_CSS_PROP_SHORTHAND
 #endif
 
 #define CSS_PROP_DOMPROP_PREFIXED(name_) \
   CSS_PROP_PUBLIC_OR_PRIVATE(Moz ## name_, name_)
 
 // Callers may define CSS_PROP_LIST_EXCLUDE_INTERNAL if they want to
 // exclude internal properties that are not represented in the DOM (only
 // the DOM style code defines this).  All properties defined in an
 // #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL section must have the
-// CSSPropFlags::Internal flag set.
+// CSS_PROPERTY_INTERNAL flag set.
 
 // Callers may also define CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 // to exclude properties that are not considered to be components of the 'all'
 // shorthand property.  Currently this excludes 'direction' and 'unicode-bidi',
 // as required by the CSS Cascading and Inheritance specification, and any
 // internal properties that cannot be changed by using CSS syntax.  For example,
 // the internal '-moz-system-font' property is not excluded, as it is set by the
 // 'font' shorthand, while '-x-lang' is excluded as there is no way to set this
@@ -88,25 +90,25 @@
 
 // A caller who wants all the properties can define the |CSS_PROP|
 // macro.
 #ifdef CSS_PROP
 
 #define USED_CSS_PROP
 // We still need this extra level so that CSS_PROP_DOMPROP_PREFIXED has
 // a chance to be expanded.
-#define CSS_PROP_(name_, id_, method_, pref_, parsevariant_, kwtable_) CSS_PROP(name_, id_, method_, pref_, parsevariant_, kwtable_)
+#define CSS_PROP_(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_) CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_)
 
 #else /* !defined(CSS_PROP) */
 
 // An includer who does not define CSS_PROP can define any or all of the
 // per-struct macros that are equivalent to it, and the rest will be
 // ignored.
 
-#define CSS_PROP_(name_, id_, method_, pref_, parsevariant_, kwtable_) /* nothing */
+#define CSS_PROP_(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_) /* nothing */
 
 #endif /* !defined(CSS_PROP) */
 
 /*************************************************************************/
 
 // For notes XXX bug 3935 below, the names being parsed do not correspond
 // to the constants used internally.  It would be nice to bring the
 // constants into line sometime.
@@ -137,2600 +139,2990 @@
 
 // Please keep these sorted by property name, ignoring any "-moz-",
 // "-webkit-" or "-x-" prefix.
 
 CSS_PROP_(
     align-content,
     align_content,
     AlignContent,
+    0,
     "",
     VARIANT_HK,
     kAutoCompletionAlignJustifyContent)
 CSS_PROP_(
     align-items,
     align_items,
     AlignItems,
+    0,
     "",
     VARIANT_HK,
     kAutoCompletionAlignItems)
 CSS_PROP_(
     align-self,
     align_self,
     AlignSelf,
+    0,
     "",
     VARIANT_HK,
     kAutoCompletionAlignJustifySelf)
 CSS_PROP_SHORTHAND(
     all,
     all,
     All,
+    0,
     "layout.css.all-shorthand.enabled")
 CSS_PROP_SHORTHAND(
     animation,
     animation,
     Animation,
+    0,
     "")
 CSS_PROP_(
     animation-delay,
     animation_delay,
     AnimationDelay,
+    0,
     "",
     VARIANT_TIME, // used by list parsing
     nullptr)
 CSS_PROP_(
     animation-direction,
     animation_direction,
     AnimationDirection,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kAnimationDirectionKTable)
 CSS_PROP_(
     animation-duration,
     animation_duration,
     AnimationDuration,
+    0,
     "",
     VARIANT_TIME | VARIANT_NONNEGATIVE_DIMENSION, // used by list parsing
     nullptr)
 CSS_PROP_(
     animation-fill-mode,
     animation_fill_mode,
     AnimationFillMode,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kAnimationFillModeKTable)
 CSS_PROP_(
     animation-iteration-count,
     animation_iteration_count,
     AnimationIterationCount,
+    0,
     "",
     VARIANT_KEYWORD | VARIANT_NUMBER, // used by list parsing
     kAnimationIterationCountKTable)
 CSS_PROP_(
     animation-name,
     animation_name,
     AnimationName,
+    0,
     "",
     // FIXME: The spec should say something about 'inherit' and 'initial'
     // not being allowed.
     VARIANT_NONE | VARIANT_IDENTIFIER_NO_INHERIT | VARIANT_STRING, // used by list parsing
     nullptr)
 CSS_PROP_(
     animation-play-state,
     animation_play_state,
     AnimationPlayState,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kAnimationPlayStateKTable)
 CSS_PROP_(
     animation-timing-function,
     animation_timing_function,
     AnimationTimingFunction,
+    0,
     "",
     VARIANT_KEYWORD | VARIANT_TIMING_FUNCTION, // used by list parsing
     kTransitionTimingFunctionKTable)
 CSS_PROP_(
     -moz-appearance,
     _moz_appearance,
     CSS_PROP_DOMPROP_PREFIXED(Appearance),
+    0,
     "",
     VARIANT_HK,
     kAppearanceKTable)
 CSS_PROP_(
     backface-visibility,
     backface_visibility,
     BackfaceVisibility,
+    0,
     "",
     VARIANT_HK,
     kBackfaceVisibilityKTable)
 CSS_PROP_SHORTHAND(
     background,
     background,
     Background,
+    0,
     "")
 CSS_PROP_(
     background-attachment,
     background_attachment,
     BackgroundAttachment,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kImageLayerAttachmentKTable)
 CSS_PROP_(
     background-blend-mode,
     background_blend_mode,
     BackgroundBlendMode,
+    0,
     "layout.css.background-blend-mode.enabled",
     VARIANT_KEYWORD, // used by list parsing
     kBlendModeKTable)
 CSS_PROP_(
     background-clip,
     background_clip,
     BackgroundClip,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kBackgroundClipKTable)
 CSS_PROP_(
     background-color,
     background_color,
     BackgroundColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     background-image,
     background_image,
     BackgroundImage,
+    0,
     "",
     VARIANT_IMAGE, // used by list parsing
     nullptr)
 CSS_PROP_(
     background-origin,
     background_origin,
     BackgroundOrigin,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kBackgroundOriginKTable)
 CSS_PROP_SHORTHAND(
     background-position,
     background_position,
     BackgroundPosition,
+    0,
     "")
 CSS_PROP_(
     background-position-x,
     background_position_x,
     BackgroundPositionX,
+    0,
     "",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     background-position-y,
     background_position_y,
     BackgroundPositionY,
+    0,
     "",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     background-repeat,
     background_repeat,
     BackgroundRepeat,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kImageLayerRepeatKTable)
 CSS_PROP_(
     background-size,
     background_size,
     BackgroundSize,
+    0,
     "",
     0,
     kImageLayerSizeKTable)
 CSS_PROP_(
     -moz-binding,
     _moz_binding,
     CSS_PROP_DOMPROP_PREFIXED(Binding),
+    0,
     "",
     VARIANT_HUO,
     nullptr) // XXX bug 3935
 CSS_PROP_(
     block-size,
     block_size,
     BlockSize,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_SHORTHAND(
     border,
     border,
     Border,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     border-block-end,
     border_block_end,
     BorderBlockEnd,
+    0,
     "")
 CSS_PROP_(
     border-block-end-color,
     border_block_end_color,
     BorderBlockEndColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-block-end-style,
     border_block_end_style,
     BorderBlockEndStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-block-end-width,
     border_block_end_width,
     BorderBlockEndWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-block-start,
     border_block_start,
     BorderBlockStart,
+    0,
     "")
 CSS_PROP_(
     border-block-start-color,
     border_block_start_color,
     BorderBlockStartColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-block-start-style,
     border_block_start_style,
     BorderBlockStartStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-block-start-width,
     border_block_start_width,
     BorderBlockStartWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-bottom,
     border_bottom,
     BorderBottom,
+    0,
     "")
 CSS_PROP_(
     border-bottom-color,
     border_bottom_color,
     BorderBottomColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-bottom-left-radius,
     border_bottom_left_radius,
     BorderBottomLeftRadius,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     border-bottom-right-radius,
     border_bottom_right_radius,
     BorderBottomRightRadius,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     border-bottom-style,
     border_bottom_style,
     BorderBottomStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)  // on/off will need reflow
 CSS_PROP_(
     border-bottom-width,
     border_bottom_width,
     BorderBottomWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_(
     border-collapse,
     border_collapse,
     BorderCollapse,
+    0,
     "",
     VARIANT_HK,
     kBorderCollapseKTable)
 CSS_PROP_SHORTHAND(
     border-color,
     border_color,
     BorderColor,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     border-image,
     border_image,
     BorderImage,
+    0,
     "")
 CSS_PROP_(
     border-image-outset,
     border_image_outset,
     BorderImageOutset,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     border-image-repeat,
     border_image_repeat,
     BorderImageRepeat,
+    0,
     "",
     0,
     kBorderImageRepeatKTable)
 CSS_PROP_(
     border-image-slice,
     border_image_slice,
     BorderImageSlice,
+    0,
     "",
     0,
     kBorderImageSliceKTable)
 CSS_PROP_(
     border-image-source,
     border_image_source,
     BorderImageSource,
+    0,
     "",
     VARIANT_IMAGE | VARIANT_INHERIT,
     nullptr)
 CSS_PROP_(
     border-image-width,
     border_image_width,
     BorderImageWidth,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     border-inline-end,
     border_inline_end,
     BorderInlineEnd,
+    0,
     "")
 CSS_PROP_(
     border-inline-end-color,
     border_inline_end_color,
     BorderInlineEndColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-inline-end-style,
     border_inline_end_style,
     BorderInlineEndStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-inline-end-width,
     border_inline_end_width,
     BorderInlineEndWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-inline-start,
     border_inline_start,
     BorderInlineStart,
+    0,
     "")
 CSS_PROP_(
     border-inline-start-color,
     border_inline_start_color,
     BorderInlineStartColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-inline-start-style,
     border_inline_start_style,
     BorderInlineStartStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-inline-start-width,
     border_inline_start_width,
     BorderInlineStartWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-left,
     border_left,
     BorderLeft,
+    0,
     "")
 CSS_PROP_(
     border-left-color,
     border_left_color,
     BorderLeftColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-left-style,
     border_left_style,
     BorderLeftStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-left-width,
     border_left_width,
     BorderLeftWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-radius,
     border_radius,
     BorderRadius,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     border-right,
     border_right,
     BorderRight,
+    0,
     "")
 CSS_PROP_(
     border-right-color,
     border_right_color,
     BorderRightColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-right-style,
     border_right_style,
     BorderRightStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     border-right-width,
     border_right_width,
     BorderRightWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_(
     border-spacing,
     border_spacing,
     BorderSpacing,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     border-style,
     border_style,
     BorderStyle,
+    0,
     "")  // on/off will need reflow
 CSS_PROP_SHORTHAND(
     border-top,
     border_top,
     BorderTop,
+    0,
     "")
 CSS_PROP_(
     border-top-color,
     border_top_color,
     BorderTopColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     border-top-left-radius,
     border_top_left_radius,
     BorderTopLeftRadius,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     border-top-right-radius,
     border_top_right_radius,
     BorderTopRightRadius,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     border-top-style,
     border_top_style,
     BorderTopStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)  // on/off will need reflow
 CSS_PROP_(
     border-top-width,
     border_top_width,
     BorderTopWidth,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     border-width,
     border_width,
     BorderWidth,
+    0,
     "")
 CSS_PROP_(
     bottom,
     bottom,
     Bottom,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     -moz-box-align,
     _moz_box_align,
     CSS_PROP_DOMPROP_PREFIXED(BoxAlign),
+    0,
     "",
     VARIANT_HK,
     kBoxAlignKTable) // XXX bug 3935
 CSS_PROP_(
     box-decoration-break,
     box_decoration_break,
     BoxDecorationBreak,
+    0,
     "layout.css.box-decoration-break.enabled",
     VARIANT_HK,
     kBoxDecorationBreakKTable)
 CSS_PROP_(
     -moz-box-direction,
     _moz_box_direction,
     CSS_PROP_DOMPROP_PREFIXED(BoxDirection),
+    0,
     "",
     VARIANT_HK,
     kBoxDirectionKTable) // XXX bug 3935
 CSS_PROP_(
     -moz-box-flex,
     _moz_box_flex,
     CSS_PROP_DOMPROP_PREFIXED(BoxFlex),
+    0,
     "",
     VARIANT_HN,
     nullptr) // XXX bug 3935
 CSS_PROP_(
     -moz-box-ordinal-group,
     _moz_box_ordinal_group,
     CSS_PROP_DOMPROP_PREFIXED(BoxOrdinalGroup),
+    0,
     "",
     VARIANT_HI,
     nullptr)
 CSS_PROP_(
     -moz-box-orient,
     _moz_box_orient,
     CSS_PROP_DOMPROP_PREFIXED(BoxOrient),
+    0,
     "",
     VARIANT_HK,
     kBoxOrientKTable) // XXX bug 3935
 CSS_PROP_(
     -moz-box-pack,
     _moz_box_pack,
     CSS_PROP_DOMPROP_PREFIXED(BoxPack),
+    0,
     "",
     VARIANT_HK,
     kBoxPackKTable) // XXX bug 3935
 CSS_PROP_(
     box-shadow,
     box_shadow,
     BoxShadow,
+    0,
         // NOTE: some components must be nonnegative
     "",
     VARIANT_COLOR | VARIANT_LENGTH | VARIANT_CALC | VARIANT_INHERIT | VARIANT_NONE,
     kBoxShadowTypeKTable)
 CSS_PROP_(
     box-sizing,
     box_sizing,
     BoxSizing,
+    0,
     "",
     VARIANT_HK,
     kBoxSizingKTable)
 CSS_PROP_(
     caption-side,
     caption_side,
     CaptionSide,
+    0,
     "",
     VARIANT_HK,
     kCaptionSideKTable)
 CSS_PROP_(
     caret-color,
     caret_color,
     CaretColor,
+    0,
     "",
     VARIANT_AUTO | VARIANT_HC,
     nullptr)
 CSS_PROP_(
     clear,
     clear,
     Clear,
+    0,
     "",
     VARIANT_HK,
     kClearKTable)
 CSS_PROP_(
     clip,
     clip,
     Clip,
+    0,
     "",
     VARIANT_AH,
     nullptr)
 CSS_PROP_(
     clip-path,
     clip_path,
     ClipPath,
+    0,
     "",
     VARIANT_HUO,
     nullptr)
 CSS_PROP_(
     clip-rule,
     clip_rule,
     ClipRule,
+    0,
     "",
     VARIANT_HK,
     kFillRuleKTable)
 CSS_PROP_(
     color,
     color,
     Color,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     color-adjust,
     color_adjust,
     ColorAdjust,
+    0,
     "layout.css.color-adjust.enabled",
     VARIANT_HK,
     kColorAdjustKTable)
 CSS_PROP_(
     color-interpolation,
     color_interpolation,
     ColorInterpolation,
+    0,
     "",
     VARIANT_HK,
     kColorInterpolationKTable)
 CSS_PROP_(
     color-interpolation-filters,
     color_interpolation_filters,
     ColorInterpolationFilters,
+    0,
     "",
     VARIANT_HK,
     kColorInterpolationKTable)
 CSS_PROP_(
     column-count,
     column_count,
     ColumnCount,
+    0,
     "",
     VARIANT_AHI,
     nullptr)
 CSS_PROP_(
     column-fill,
     column_fill,
     ColumnFill,
+    0,
     "",
     VARIANT_HK,
     kColumnFillKTable)
 CSS_PROP_(
     column-gap,
     column_gap,
     ColumnGap,
+    0,
     "",
     VARIANT_HLP | VARIANT_NORMAL | VARIANT_CALC,
     nullptr)
 CSS_PROP_SHORTHAND(
     column-rule,
     column_rule,
     ColumnRule,
+    0,
     "")
 CSS_PROP_(
     column-rule-color,
     column_rule_color,
     ColumnRuleColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     column-rule-style,
     column_rule_style,
     ColumnRuleStyle,
+    0,
     "",
     VARIANT_HK,
     kBorderStyleKTable)
 CSS_PROP_(
     column-rule-width,
     column_rule_width,
     ColumnRuleWidth,
+    0,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_(
     column-span,
     column_span,
     ColumnSpan,
+    0,
     "layout.css.column-span.enabled",
     VARIANT_HK,
     kColumnSpanKTable)
 CSS_PROP_(
     column-width,
     column_width,
     ColumnWidth,
+    0,
     "",
     VARIANT_AHL | VARIANT_CALC,
     nullptr)
 CSS_PROP_SHORTHAND(
     columns,
     columns,
     Columns,
+    0,
     "")
 CSS_PROP_(
     contain,
     contain,
     Contain,
+    0,
     "layout.css.contain.enabled",
     // Does not affect parsing, but is needed for tab completion in devtools:
     VARIANT_HK | VARIANT_NONE,
     kContainKTable)
 CSS_PROP_(
     content,
     content,
     Content,
+    0,
     "",
     VARIANT_HMK | VARIANT_NONE | VARIANT_URL | VARIANT_COUNTER | VARIANT_ATTR,
     kContentKTable)
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     // Only intended to be used internally by Mozilla, so prefixed.
     -moz-context-properties,
     _moz_context_properties,
     CSS_PROP_DOMPROP_PREFIXED(ContextProperties),
+    CSS_PROPERTY_INTERNAL,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-control-character-visibility,
     _moz_control_character_visibility,
     CSS_PROP_DOMPROP_PREFIXED(ControlCharacterVisibility),
+    CSS_PROPERTY_INTERNAL,
     "",
     VARIANT_HK,
     kControlCharacterVisibilityKTable)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     counter-increment,
     counter_increment,
     CounterIncrement,
+    0,
     "",
     VARIANT_INHERIT | VARIANT_NONE,
     nullptr) // XXX bug 137285
 CSS_PROP_(
     counter-reset,
     counter_reset,
     CounterReset,
+    0,
     "",
     VARIANT_INHERIT | VARIANT_NONE,
     nullptr) // XXX bug 137285
 CSS_PROP_(
     cursor,
     cursor,
     Cursor,
+    0,
     "",
     0,
     kCursorKTable)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     direction,
     direction,
     Direction,
+    0,
     "",
     VARIANT_HK,
     kDirectionKTable)
 #endif // !defined(CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND)
 CSS_PROP_(
     display,
     display,
     Display,
+    0,
     "",
     VARIANT_HK,
     kDisplayKTable)
 CSS_PROP_(
     dominant-baseline,
     dominant_baseline,
     DominantBaseline,
+    0,
     "",
     VARIANT_HK,
     kDominantBaselineKTable)
 CSS_PROP_(
     empty-cells,
     empty_cells,
     EmptyCells,
+    0,
     "",
     VARIANT_HK,
     kEmptyCellsKTable)
 CSS_PROP_(
     fill,
     fill,
     Fill,
+    0,
     "",
     0,
     kContextPatternKTable)
 CSS_PROP_(
     fill-opacity,
     fill_opacity,
     FillOpacity,
+    0,
     "",
     VARIANT_HN | VARIANT_KEYWORD,
     kContextOpacityKTable)
 CSS_PROP_(
     fill-rule,
     fill_rule,
     FillRule,
+    0,
     "",
     VARIANT_HK,
     kFillRuleKTable)
 CSS_PROP_(
     filter,
     filter,
     Filter,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     flex,
     flex,
     Flex,
+    0,
     "")
 CSS_PROP_(
     flex-basis,
     flex_basis,
     FlexBasis,
+    0,
     "",
     // NOTE: The parsing implementation for the 'flex' shorthand property has
     // its own code to parse each subproperty. It does not depend on the
     // longhand parsing defined here.
     VARIANT_AHKLP | VARIANT_CALC,
     kFlexBasisKTable)
 CSS_PROP_(
     flex-direction,
     flex_direction,
     FlexDirection,
+    0,
     "",
     VARIANT_HK,
     kFlexDirectionKTable)
 CSS_PROP_SHORTHAND(
     flex-flow,
     flex_flow,
     FlexFlow,
+    0,
     "")
 CSS_PROP_(
     flex-grow,
     flex_grow,
     FlexGrow,
+    0,
     "",
     // NOTE: The parsing implementation for the 'flex' shorthand property has
     // its own code to parse each subproperty. It does not depend on the
     // longhand parsing defined here.
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     flex-shrink,
     flex_shrink,
     FlexShrink,
+    0,
     "",
     // NOTE: The parsing implementation for the 'flex' shorthand property has
     // its own code to parse each subproperty. It does not depend on the
     // longhand parsing defined here.
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     flex-wrap,
     flex_wrap,
     FlexWrap,
+    0,
     "",
     VARIANT_HK,
     kFlexWrapKTable)
 CSS_PROP_(
     float,
     float,
     CSS_PROP_PUBLIC_OR_PRIVATE(CssFloat, Float),
+    0,
     "",
     VARIANT_HK,
     kFloatKTable)
 CSS_PROP_(
     -moz-float-edge,
     _moz_float_edge,
     CSS_PROP_DOMPROP_PREFIXED(FloatEdge),
+    0,
     "",
     VARIANT_HK,
     kFloatEdgeKTable) // XXX bug 3935
 CSS_PROP_(
     flood-color,
     flood_color,
     FloodColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     flood-opacity,
     flood_opacity,
     FloodOpacity,
+    0,
     "",
     VARIANT_HN,
     nullptr)
 CSS_PROP_SHORTHAND(
     font,
     font,
     Font,
+    0,
     "")
 CSS_PROP_(
     font-family,
     font_family,
     FontFamily,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     font-feature-settings,
     font_feature_settings,
     FontFeatureSettings,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     font-kerning,
     font_kerning,
     FontKerning,
+    0,
     "",
     VARIANT_HK,
     kFontKerningKTable)
 CSS_PROP_(
     font-language-override,
     font_language_override,
     FontLanguageOverride,
+    0,
     "",
     VARIANT_NORMAL | VARIANT_INHERIT | VARIANT_STRING,
     nullptr)
 CSS_PROP_(
     font-optical-sizing,
     font_optical_sizing,
     FontOpticalSizing,
+    0,
     "layout.css.font-variations.enabled",
     VARIANT_HK,
     kFontOpticalSizingKTable)
 CSS_PROP_(
     font-size,
     font_size,
     FontSize,
+    0,
     "",
     VARIANT_HKLP | VARIANT_SYSFONT | VARIANT_CALC,
     kFontSizeKTable)
 CSS_PROP_(
     font-size-adjust,
     font_size_adjust,
     FontSizeAdjust,
+    0,
     "",
     VARIANT_HON | VARIANT_SYSFONT,
     nullptr)
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-font-smoothing-background-color,
     _moz_font_smoothing_background_color,
     CSS_PROP_DOMPROP_PREFIXED(FontSmoothingBackgroundColor),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS_AND_CHROME,
     "",
     VARIANT_HC,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     font-stretch,
     font_stretch,
     FontStretch,
+    0,
     "",
     VARIANT_HK | VARIANT_SYSFONT | VARIANT_PERCENT,
     kFontStretchKTable)
 CSS_PROP_(
     font-style,
     font_style,
     FontStyle,
+    0,
     "",
     VARIANT_HK | VARIANT_SYSFONT,
     kFontStyleKTable)
 CSS_PROP_(
     font-synthesis,
     font_synthesis,
     FontSynthesis,
+    0,
     "",
     0,
     kFontSynthesisKTable)
 CSS_PROP_SHORTHAND(
     font-variant,
     font_variant,
     FontVariant,
+    0,
     "")
 CSS_PROP_(
     font-variant-alternates,
     font_variant_alternates,
     FontVariantAlternates,
+    0,
     "",
     0,
     kFontVariantAlternatesKTable)
 CSS_PROP_(
     font-variant-caps,
     font_variant_caps,
     FontVariantCaps,
+    0,
     "",
     VARIANT_HMK,
     kFontVariantCapsKTable)
 CSS_PROP_(
     font-variant-east-asian,
     font_variant_east_asian,
     FontVariantEastAsian,
+    0,
     "",
     0,
     kFontVariantEastAsianKTable)
 CSS_PROP_(
     font-variant-ligatures,
     font_variant_ligatures,
     FontVariantLigatures,
+    0,
     "",
     0,
     kFontVariantLigaturesKTable)
 CSS_PROP_(
     font-variant-numeric,
     font_variant_numeric,
     FontVariantNumeric,
+    0,
     "",
     0,
     kFontVariantNumericKTable)
 CSS_PROP_(
     font-variant-position,
     font_variant_position,
     FontVariantPosition,
+    0,
     "",
     VARIANT_HMK,
     kFontVariantPositionKTable)
 CSS_PROP_(
     font-variation-settings,
     font_variation_settings,
     FontVariationSettings,
+    0,
     "layout.css.font-variations.enabled",
     0,
     nullptr)
 CSS_PROP_(
     font-weight,
     font_weight,
     FontWeight,
+    0,
         // NOTE: This property has range restrictions on interpolation!
     "",
     0,
     kFontWeightKTable)
 CSS_PROP_(
     -moz-force-broken-image-icon,
     _moz_force_broken_image_icon,
     CSS_PROP_DOMPROP_PREFIXED(ForceBrokenImageIcon),
+    0,
     "",
     VARIANT_HI,
     nullptr) // bug 58646
 CSS_PROP_SHORTHAND(
     gap,
     gap,
     Gap,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     grid,
     grid,
     Grid,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     grid-area,
     grid_area,
     GridArea,
+    0,
     "")
 CSS_PROP_(
     grid-auto-columns,
     grid_auto_columns,
     GridAutoColumns,
+    0,
     "",
     0,
     kGridTrackBreadthKTable)
 CSS_PROP_(
     grid-auto-flow,
     grid_auto_flow,
     GridAutoFlow,
+    0,
     "",
     0,
     kGridAutoFlowKTable)
 CSS_PROP_(
     grid-auto-rows,
     grid_auto_rows,
     GridAutoRows,
+    0,
     "",
     0,
     kGridTrackBreadthKTable)
 CSS_PROP_SHORTHAND(
     grid-column,
     grid_column,
     GridColumn,
+    0,
     "")
 CSS_PROP_(
     grid-column-end,
     grid_column_end,
     GridColumnEnd,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     grid-column-start,
     grid_column_start,
     GridColumnStart,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     grid-row,
     grid_row,
     GridRow,
+    0,
     "")
 CSS_PROP_(
     grid-row-end,
     grid_row_end,
     GridRowEnd,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     grid-row-start,
     grid_row_start,
     GridRowStart,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     grid-template,
     grid_template,
     GridTemplate,
+    0,
     "")
 CSS_PROP_(
     grid-template-areas,
     grid_template_areas,
     GridTemplateAreas,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     grid-template-columns,
     grid_template_columns,
     GridTemplateColumns,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     0,
     kGridTrackBreadthKTable)
 CSS_PROP_(
     grid-template-rows,
     grid_template_rows,
     GridTemplateRows,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     0,
     kGridTrackBreadthKTable)
 CSS_PROP_(
     height,
     height,
     Height,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     hyphens,
     hyphens,
     Hyphens,
+    0,
     "",
     VARIANT_HK,
     kHyphensKTable)
 CSS_PROP_(
     image-orientation,
     image_orientation,
     ImageOrientation,
+    0,
     "layout.css.image-orientation.enabled",
     0,
     kImageOrientationKTable)
 CSS_PROP_(
     -moz-image-region,
     _moz_image_region,
     CSS_PROP_DOMPROP_PREFIXED(ImageRegion),
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     image-rendering,
     image_rendering,
     ImageRendering,
+    0,
     "",
     VARIANT_HK,
     kImageRenderingKTable)
 CSS_PROP_(
     ime-mode,
     ime_mode,
     ImeMode,
+    0,
     "",
     VARIANT_HK,
     kIMEModeKTable)
 CSS_PROP_(
     initial-letter,
     initial_letter,
     InitialLetter,
+    0,
     "layout.css.initial-letter.enabled",
     0,
     nullptr)
 CSS_PROP_(
     inline-size,
     inline_size,
     InlineSize,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     isolation,
     isolation,
     Isolation,
+    0,
     "layout.css.isolation.enabled",
     VARIANT_HK,
     kIsolationKTable)
 CSS_PROP_(
     justify-content,
     justify_content,
     JustifyContent,
+    0,
     "",
     VARIANT_HK,
     kAutoCompletionAlignJustifyContent)
 CSS_PROP_(
     justify-items,
     justify_items,
     JustifyItems,
+    0,
     "",
     VARIANT_HK,
     // for auto-completion we use same values as justify-self:
     kAutoCompletionAlignJustifySelf)
 CSS_PROP_(
     justify-self,
     justify_self,
     JustifySelf,
+    0,
     "",
     VARIANT_HK,
     kAutoCompletionAlignJustifySelf)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -x-lang,
     _x_lang,
     Lang,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     0,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     left,
     left,
     Left,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     letter-spacing,
     letter_spacing,
     LetterSpacing,
+    0,
     "",
     VARIANT_HL | VARIANT_NORMAL | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     lighting-color,
     lighting_color,
     LightingColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     line-height,
     line_height,
     LineHeight,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLPN | VARIANT_KEYWORD | VARIANT_NORMAL | VARIANT_SYSFONT | VARIANT_CALC,
     kLineHeightKTable)
 CSS_PROP_SHORTHAND(
     list-style,
     list_style,
     ListStyle,
+    0,
     "")
 CSS_PROP_(
     list-style-image,
     list_style_image,
     ListStyleImage,
+    0,
     "",
     VARIANT_HUO,
     nullptr)
 CSS_PROP_(
     list-style-position,
     list_style_position,
     ListStylePosition,
+    0,
     "",
     VARIANT_HK,
     kListStylePositionKTable)
 CSS_PROP_(
     list-style-type,
     list_style_type,
     ListStyleType,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     margin,
     margin,
     Margin,
+    0,
     "")
 CSS_PROP_(
     margin-block-end,
     margin_block_end,
     MarginBlockEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-block-start,
     margin_block_start,
     MarginBlockStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-bottom,
     margin_bottom,
     MarginBottom,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-inline-end,
     margin_inline_end,
     MarginInlineEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-inline-start,
     margin_inline_start,
     MarginInlineStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-left,
     margin_left,
     MarginLeft,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-right,
     margin_right,
     MarginRight,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     margin-top,
     margin_top,
     MarginTop,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_SHORTHAND(
     marker,
     marker,
     Marker,
+    0,
     "")
 CSS_PROP_(
     marker-end,
     marker_end,
     MarkerEnd,
+    0,
     "",
     VARIANT_HUO,
     nullptr)
 CSS_PROP_(
     marker-mid,
     marker_mid,
     MarkerMid,
+    0,
     "",
     VARIANT_HUO,
     nullptr)
 CSS_PROP_(
     marker-start,
     marker_start,
     MarkerStart,
+    0,
     "",
     VARIANT_HUO,
     nullptr)
 CSS_PROP_SHORTHAND(
     mask,
     mask,
     Mask,
+    0,
     "")
 CSS_PROP_(
     mask-clip,
     mask_clip,
     MaskClip,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kMaskClipKTable)
 CSS_PROP_(
     mask-composite,
     mask_composite,
     MaskComposite,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kImageLayerCompositeKTable)
 CSS_PROP_(
     mask-image,
     mask_image,
     MaskImage,
+    0,
     "",
     VARIANT_IMAGE, // used by list parsing
     nullptr)
 CSS_PROP_(
     mask-mode,
     mask_mode,
     MaskMode,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kImageLayerModeKTable)
 CSS_PROP_(
     mask-origin,
     mask_origin,
     MaskOrigin,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kMaskOriginKTable)
 CSS_PROP_SHORTHAND(
     mask-position,
     mask_position,
     MaskPosition,
+    0,
     "")
 CSS_PROP_(
     mask-position-x,
     mask_position_x,
     MaskPositionX,
+    0,
     "",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     mask-position-y,
     mask_position_y,
     MaskPositionY,
+    0,
     "",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     mask-repeat,
     mask_repeat,
     MaskRepeat,
+    0,
     "",
     VARIANT_KEYWORD, // used by list parsing
     kImageLayerRepeatKTable)
 CSS_PROP_(
     mask-size,
     mask_size,
     MaskSize,
+    0,
     "",
     0,
     kImageLayerSizeKTable)
 CSS_PROP_(
     mask-type,
     mask_type,
     MaskType,
+    0,
     "",
     VARIANT_HK,
     kMaskTypeKTable)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-math-display,
     _moz_math_display,
     MathDisplay,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "",
     VARIANT_HK,
     kMathDisplayKTable)
 CSS_PROP_(
     -moz-math-variant,
     _moz_math_variant,
     MathVariant,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     VARIANT_HK,
     kMathVariantKTable)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     max-block-size,
     max_block_size,
     MaxBlockSize,
+    0,
     "",
     VARIANT_HLPO | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     max-height,
     max_height,
     MaxHeight,
+    0,
     "",
     VARIANT_HKLPO | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     max-inline-size,
     max_inline_size,
     MaxInlineSize,
+    0,
     "",
     VARIANT_HKLPO | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     max-width,
     max_width,
     MaxWidth,
+    0,
     "",
     VARIANT_HKLPO | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     min-block-size,
     min_block_size,
     MinBlockSize,
+    0,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-min-font-size-ratio,
     _moz_min_font_size_ratio,
     CSS_PROP_DOMPROP_PREFIXED(MinFontSizeRatio),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "",
     VARIANT_INHERIT | VARIANT_PERCENT,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     min-height,
     min_height,
     MinHeight,
+    0,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     min-inline-size,
     min_inline_size,
     MinInlineSize,
+    0,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     min-width,
     min_width,
     MinWidth,
+    0,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     mix-blend-mode,
     mix_blend_mode,
     MixBlendMode,
+    0,
     "layout.css.mix-blend-mode.enabled",
     VARIANT_HK,
     kBlendModeKTable)
 CSS_PROP_(
     object-fit,
     object_fit,
     ObjectFit,
+    0,
     "",
     VARIANT_HK,
     kObjectFitKTable)
 CSS_PROP_(
     object-position,
     object_position,
     ObjectPosition,
+    0,
     "",
     VARIANT_CALC,
     kImageLayerPositionKTable)
 CSS_PROP_(
     offset-block-end,
     offset_block_end,
     OffsetBlockEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     offset-block-start,
     offset_block_start,
     OffsetBlockStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     offset-inline-end,
     offset_inline_end,
     OffsetInlineEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     offset-inline-start,
     offset_inline_start,
     OffsetInlineStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     opacity,
     opacity,
     Opacity,
+    CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR,
     "",
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     order,
     order,
     Order,
+    0,
     "",
     VARIANT_HI,
     nullptr) // <integer>
 CSS_PROP_(
     -moz-orient,
     _moz_orient,
     CSS_PROP_DOMPROP_PREFIXED(Orient),
+    0,
     "",
     VARIANT_HK,
     kOrientKTable)
 CSS_PROP_(
     -moz-osx-font-smoothing,
     _moz_osx_font_smoothing,
     CSS_PROP_DOMPROP_PREFIXED(OsxFontSmoothing),
+    0,
     "layout.css.osx-font-smoothing.enabled",
     VARIANT_HK,
     kFontSmoothingKTable)
 CSS_PROP_SHORTHAND(
     outline,
     outline,
     Outline,
+    0,
     "")
 CSS_PROP_(
     outline-color,
     outline_color,
     OutlineColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     outline-offset,
     outline_offset,
     OutlineOffset,
+    0,
     "",
     VARIANT_HL | VARIANT_CALC,
     nullptr)
 CSS_PROP_SHORTHAND(
     -moz-outline-radius,
     _moz_outline_radius,
     CSS_PROP_DOMPROP_PREFIXED(OutlineRadius),
+    0,
     "")
 CSS_PROP_(
     -moz-outline-radius-bottomleft,
     _moz_outline_radius_bottomleft,
     CSS_PROP_DOMPROP_PREFIXED(OutlineRadiusBottomleft),
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-outline-radius-bottomright,
     _moz_outline_radius_bottomright,
     CSS_PROP_DOMPROP_PREFIXED(OutlineRadiusBottomright),
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-outline-radius-topleft,
     _moz_outline_radius_topleft,
     CSS_PROP_DOMPROP_PREFIXED(OutlineRadiusTopleft),
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-outline-radius-topright,
     _moz_outline_radius_topright,
     CSS_PROP_DOMPROP_PREFIXED(OutlineRadiusTopright),
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     outline-style,
     outline_style,
     OutlineStyle,
+    0,
     "",
     VARIANT_HK,
     kOutlineStyleKTable)
 CSS_PROP_(
     outline-width,
     outline_width,
     OutlineWidth,
+    0,
     "",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_SHORTHAND(
     overflow,
     overflow,
     Overflow,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     overflow-clip-box,
     overflow_clip_box,
     OverflowClipBox,
+    CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "layout.css.overflow-clip-box.enabled")
 CSS_PROP_(
     overflow-clip-box-block,
     overflow_clip_box_block,
     OverflowClipBoxBlock,
+    CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "layout.css.overflow-clip-box.enabled",
     VARIANT_HK,
     kOverflowClipBoxKTable)
 CSS_PROP_(
     overflow-clip-box-inline,
     overflow_clip_box_inline,
     OverflowClipBoxInline,
+    CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "layout.css.overflow-clip-box.enabled",
     VARIANT_HK,
     kOverflowClipBoxKTable)
 CSS_PROP_(
     overflow-wrap,
     overflow_wrap,
     OverflowWrap,
+    0,
     "",
     VARIANT_HK,
     kOverflowWrapKTable)
 CSS_PROP_(
     overflow-x,
     overflow_x,
     OverflowX,
+    0,
     "",
     VARIANT_HK,
     kOverflowSubKTable)
 CSS_PROP_(
     overflow-y,
     overflow_y,
     OverflowY,
+    0,
     "",
     VARIANT_HK,
     kOverflowSubKTable)
 CSS_PROP_SHORTHAND(
     overscroll-behavior,
     overscroll_behavior,
     OverscrollBehavior,
+    0,
     "layout.css.overscroll-behavior.enabled")
 CSS_PROP_(
     overscroll-behavior-x,
     overscroll_behavior_x,
     OverscrollBehaviorX,
+    0,
     "layout.css.overscroll-behavior.enabled",
     VARIANT_HK,
     kOverscrollBehaviorKTable)
 CSS_PROP_(
     overscroll-behavior-y,
     overscroll_behavior_y,
     OverscrollBehaviorY,
+    0,
     "layout.css.overscroll-behavior.enabled",
     VARIANT_HK,
     kOverscrollBehaviorKTable)
 CSS_PROP_SHORTHAND(
     padding,
     padding,
     Padding,
+    0,
     "")
 CSS_PROP_(
     padding-block-end,
     padding_block_end,
     PaddingBlockEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-block-start,
     padding_block_start,
     PaddingBlockStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-bottom,
     padding_bottom,
     PaddingBottom,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-inline-end,
     padding_inline_end,
     PaddingInlineEnd,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-inline-start,
     padding_inline_start,
     PaddingInlineStart,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-left,
     padding_left,
     PaddingLeft,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-right,
     padding_right,
     PaddingRight,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     padding-top,
     padding_top,
     PaddingTop,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     page-break-after,
     page_break_after,
     PageBreakAfter,
+    0,
     "",
     VARIANT_HK,
     kPageBreakKTable) // temp fix for bug 24000
 CSS_PROP_(
     page-break-before,
     page_break_before,
     PageBreakBefore,
+    0,
     "",
     VARIANT_HK,
     kPageBreakKTable) // temp fix for bug 24000
 CSS_PROP_(
     page-break-inside,
     page_break_inside,
     PageBreakInside,
+    0,
     "",
     VARIANT_HK,
     kPageBreakInsideKTable)
 CSS_PROP_(
     paint-order,
     paint_order,
     PaintOrder,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     perspective,
     perspective,
     Perspective,
+    0,
     "",
     VARIANT_NONE | VARIANT_INHERIT | VARIANT_LENGTH |
       VARIANT_NONNEGATIVE_DIMENSION,
     nullptr)
 CSS_PROP_(
     perspective-origin,
     perspective_origin,
     PerspectiveOrigin,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_CALC,
     kImageLayerPositionKTable)
 CSS_PROP_SHORTHAND(
     place-content,
     place_content,
     PlaceContent,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     place-items,
     place_items,
     PlaceItems,
+    0,
     "")
 CSS_PROP_SHORTHAND(
     place-self,
     place_self,
     PlaceSelf,
+    0,
     "")
 CSS_PROP_(
     pointer-events,
     pointer_events,
     PointerEvents,
+    0,
     "",
     VARIANT_HK,
     kPointerEventsKTable)
 CSS_PROP_(
     position,
     position,
     Position,
+    0,
     "",
     VARIANT_HK,
     kPositionKTable)
 CSS_PROP_(
     quotes,
     quotes,
     Quotes,
+    0,
     "",
     VARIANT_HOS,
     nullptr)
 CSS_PROP_(
     resize,
     resize,
     Resize,
+    0,
     "",
     VARIANT_HK,
     kResizeKTable)
 CSS_PROP_(
     right,
     right,
     Right,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     rotate,
     rotate,
     Rotate,
+    0,
     "layout.css.individual-transform.enabled",
     0,
     nullptr)
 CSS_PROP_(
     row-gap,
     row_gap,
     RowGap,
+    0,
     "",
     VARIANT_HLP | VARIANT_NORMAL | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     ruby-align,
     ruby_align,
     RubyAlign,
+    0,
     "",
     VARIANT_HK,
     kRubyAlignKTable)
 CSS_PROP_(
     ruby-position,
     ruby_position,
     RubyPosition,
+    0,
     "",
     VARIANT_HK,
     kRubyPositionKTable)
 CSS_PROP_(
     scale,
     scale,
     Scale,
+    0,
     "layout.css.individual-transform.enabled",
     0,
     nullptr)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-script-level,
     _moz_script_level,
     ScriptLevel,
     // We only allow 'script-level' when unsafe rules are enabled, because
     // otherwise it could interfere with rulenode optimizations if used in
     // a non-MathML-enabled document.
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "",
     // script-level can take Auto, Integer and Number values, but only Auto
     // ("increment if parent is not in displaystyle") and Integer
     // ("relative") values can be specified in a style sheet.
     VARIANT_AHI,
     nullptr)
 CSS_PROP_(
     -moz-script-min-size,
     _moz_script_min_size,
     ScriptMinSize,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-script-size-multiplier,
     _moz_script_size_multiplier,
     ScriptSizeMultiplier,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     0,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     scroll-behavior,
     scroll_behavior,
     ScrollBehavior,
+    0,
     "layout.css.scroll-behavior.property-enabled",
     VARIANT_HK,
     kScrollBehaviorKTable)
 CSS_PROP_(
     scroll-snap-coordinate,
     scroll_snap_coordinate,
     ScrollSnapCoordinate,
+    0,
     "layout.css.scroll-snap.enabled",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     scroll-snap-destination,
     scroll_snap_destination,
     ScrollSnapDestination,
+    0,
     "layout.css.scroll-snap.enabled",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     scroll-snap-points-x,
     scroll_snap_points_x,
     ScrollSnapPointsX,
+    0,
     "layout.css.scroll-snap.enabled",
     0,
     nullptr)
 CSS_PROP_(
     scroll-snap-points-y,
     scroll_snap_points_y,
     ScrollSnapPointsY,
+    0,
     "layout.css.scroll-snap.enabled",
     0,
     nullptr)
 CSS_PROP_SHORTHAND(
     scroll-snap-type,
     scroll_snap_type,
     ScrollSnapType,
+    0,
     "layout.css.scroll-snap.enabled")
 CSS_PROP_(
     scroll-snap-type-x,
     scroll_snap_type_x,
     ScrollSnapTypeX,
+    0,
     "layout.css.scroll-snap.enabled",
     VARIANT_HK,
     kScrollSnapTypeKTable)
 CSS_PROP_(
     scroll-snap-type-y,
     scroll_snap_type_y,
     ScrollSnapTypeY,
+    0,
     "layout.css.scroll-snap.enabled",
     VARIANT_HK,
     kScrollSnapTypeKTable)
 CSS_PROP_(
     shape-image-threshold,
     shape_image_threshold,
     ShapeImageThreshold,
+    0,
     "layout.css.shape-outside.enabled",
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     shape-margin,
     shape_margin,
     ShapeMargin,
+    0,
     "layout.css.shape-outside.enabled",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     shape-outside,
     shape_outside,
     ShapeOutside,
+    0,
     "layout.css.shape-outside.enabled",
     0,
     nullptr)
 CSS_PROP_(
     shape-rendering,
     shape_rendering,
     ShapeRendering,
+    0,
     "",
     VARIANT_HK,
     kShapeRenderingKTable)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -x-span,
     _x_span,
     Span,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     0,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     -moz-stack-sizing,
     _moz_stack_sizing,
     CSS_PROP_DOMPROP_PREFIXED(StackSizing),
+    0,
     "",
     VARIANT_HK,
     kStackSizingKTable)
 CSS_PROP_(
     stop-color,
     stop_color,
     StopColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     stop-opacity,
     stop_opacity,
     StopOpacity,
+    0,
     "",
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     stroke,
     stroke,
     Stroke,
+    0,
     "",
     0,
     kContextPatternKTable)
 CSS_PROP_(
     stroke-dasharray,
     stroke_dasharray,
     StrokeDasharray,
+    0,
         // NOTE: Internal values have range restrictions.
     "",
     0,
     kStrokeContextValueKTable)
 CSS_PROP_(
     stroke-dashoffset,
     stroke_dashoffset,
     StrokeDashoffset,
+    0,
     "",
     VARIANT_HLPN | VARIANT_OPENTYPE_SVG_KEYWORD,
     kStrokeContextValueKTable)
 CSS_PROP_(
     stroke-linecap,
     stroke_linecap,
     StrokeLinecap,
+    0,
     "",
     VARIANT_HK,
     kStrokeLinecapKTable)
 CSS_PROP_(
     stroke-linejoin,
     stroke_linejoin,
     StrokeLinejoin,
+    0,
     "",
     VARIANT_HK,
     kStrokeLinejoinKTable)
 CSS_PROP_(
     stroke-miterlimit,
     stroke_miterlimit,
     StrokeMiterlimit,
+    0,
     "",
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     stroke-opacity,
     stroke_opacity,
     StrokeOpacity,
+    0,
     "",
     VARIANT_HN | VARIANT_KEYWORD,
     kContextOpacityKTable)
 CSS_PROP_(
     stroke-width,
     stroke_width,
     StrokeWidth,
+    0,
     "",
     VARIANT_HLPN | VARIANT_OPENTYPE_SVG_KEYWORD,
     kStrokeContextValueKTable)
 CSS_PROP_(
     -moz-tab-size,
     _moz_tab_size,
     CSS_PROP_DOMPROP_PREFIXED(TabSize),
+    0,
     "",
     VARIANT_INHERIT | VARIANT_LNCALC,
     nullptr)
 CSS_PROP_(
     table-layout,
     table_layout,
     TableLayout,
+    0,
     "",
     VARIANT_HK,
     kTableLayoutKTable)
 CSS_PROP_(
     text-align,
     text_align,
     TextAlign,
+    0,
     "",
     // When we support aligning on a string, we can parse text-align
     // as a string....
     VARIANT_HK /* | VARIANT_STRING */,
     kTextAlignKTable)
 CSS_PROP_(
     text-align-last,
     text_align_last,
     TextAlignLast,
+    0,
     "",
     VARIANT_HK,
     kTextAlignLastKTable)
 CSS_PROP_(
     text-anchor,
     text_anchor,
     TextAnchor,
+    0,
     "",
     VARIANT_HK,
     kTextAnchorKTable)
 CSS_PROP_(
     text-combine-upright,
     text_combine_upright,
     TextCombineUpright,
+    0,
     "layout.css.text-combine-upright.enabled",
     0,
     kTextCombineUprightKTable)
 CSS_PROP_SHORTHAND(
     text-decoration,
     text_decoration,
     TextDecoration,
+    0,
     "")
 CSS_PROP_(
     text-decoration-color,
     text_decoration_color,
     TextDecorationColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     text-decoration-line,
     text_decoration_line,
     TextDecorationLine,
+    0,
     "",
     0,
     kTextDecorationLineKTable)
 CSS_PROP_(
     text-decoration-style,
     text_decoration_style,
     TextDecorationStyle,
+    0,
     "",
     VARIANT_HK,
     kTextDecorationStyleKTable)
 CSS_PROP_SHORTHAND(
     text-emphasis,
     text_emphasis,
     TextEmphasis,
+    0,
     "")
 CSS_PROP_(
     text-emphasis-color,
     text_emphasis_color,
     TextEmphasisColor,
+    0,
     "",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     text-emphasis-position,
     text_emphasis_position,
     TextEmphasisPosition,
+    0,
     "",
     0,
     kTextEmphasisPositionKTable)
 CSS_PROP_(
     text-emphasis-style,
     text_emphasis_style,
     TextEmphasisStyle,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -webkit-text-fill-color,
     _webkit_text_fill_color,
     WebkitTextFillColor,
+    0,
     "layout.css.prefixes.webkit",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     text-indent,
     text_indent,
     TextIndent,
+    0,
     "",
     VARIANT_HLP | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     text-justify,
     text_justify,
     TextJustify,
+    0,
     "layout.css.text-justify.enabled",
     VARIANT_HK,
     kTextJustifyKTable)
 CSS_PROP_(
     text-orientation,
     text_orientation,
     TextOrientation,
+    0,
     "",
     VARIANT_HK,
     kTextOrientationKTable)
 CSS_PROP_(
     text-overflow,
     text_overflow,
     TextOverflow,
+    0,
     "",
     0,
     kTextOverflowKTable)
 CSS_PROP_(
     text-rendering,
     text_rendering,
     TextRendering,
+    0,
     "",
     VARIANT_HK,
     kTextRenderingKTable)
 CSS_PROP_(
     text-shadow,
     text_shadow,
     TextShadow,
+    0,
         // NOTE: some components must be nonnegative
     "",
     VARIANT_COLOR | VARIANT_LENGTH | VARIANT_CALC | VARIANT_INHERIT | VARIANT_NONE,
     nullptr)
 CSS_PROP_(
     -moz-text-size-adjust,
     _moz_text_size_adjust,
     CSS_PROP_DOMPROP_PREFIXED(TextSizeAdjust),
+    0,
     "",
     VARIANT_HK,
     kTextSizeAdjustKTable)
 CSS_PROP_SHORTHAND(
     -webkit-text-stroke,
     _webkit_text_stroke,
     WebkitTextStroke,
+    0,
     "layout.css.prefixes.webkit")
 CSS_PROP_(
     -webkit-text-stroke-color,
     _webkit_text_stroke_color,
     WebkitTextStrokeColor,
+    0,
     "layout.css.prefixes.webkit",
     VARIANT_HC,
     nullptr)
 CSS_PROP_(
     -webkit-text-stroke-width,
     _webkit_text_stroke_width,
     WebkitTextStrokeWidth,
+    0,
     "layout.css.prefixes.webkit",
     VARIANT_HKL | VARIANT_CALC,
     kBorderWidthKTable)
 CSS_PROP_(
     text-transform,
     text_transform,
     TextTransform,
+    0,
     "",
     VARIANT_HK,
     kTextTransformKTable)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -x-text-zoom,
     _x_text_zoom,
     TextZoom,
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_PARSE_INACCESSIBLE,
     "",
     0,
     nullptr)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     top,
     top,
     Top,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHLP | VARIANT_CALC,
     nullptr)
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-top-layer,
     _moz_top_layer,
     CSS_PROP_DOMPROP_PREFIXED(TopLayer),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
     "",
     VARIANT_HK,
     kTopLayerKTable)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     touch-action,
     touch_action,
     TouchAction,
+    0,
     "layout.css.touch_action.enabled",
     VARIANT_HK,
     kTouchActionKTable)
 CSS_PROP_(
     transform,
     transform,
     Transform,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH |
+        CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR,
     "",
     0,
     nullptr)
 CSS_PROP_(
     transform-box,
     transform_box,
     TransformBox,
+    0,
     "svg.transform-box.enabled",
     VARIANT_HK,
     kTransformBoxKTable)
 CSS_PROP_(
     transform-origin,
     transform_origin,
     TransformOrigin,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     0,
     kImageLayerPositionKTable)
 CSS_PROP_(
     transform-style,
     transform_style,
     TransformStyle,
+    0,
     "",
     VARIANT_HK,
     kTransformStyleKTable)
 CSS_PROP_SHORTHAND(
     transition,
     transition,
     Transition,
+    0,
     "")
 CSS_PROP_(
     transition-delay,
     transition_delay,
     TransitionDelay,
+    0,
     "",
     VARIANT_TIME, // used by list parsing
     nullptr)
 CSS_PROP_(
     transition-duration,
     transition_duration,
     TransitionDuration,
+    0,
     "",
     VARIANT_TIME | VARIANT_NONNEGATIVE_DIMENSION, // used by list parsing
     nullptr)
 CSS_PROP_(
     transition-property,
     transition_property,
     TransitionProperty,
+    0,
     "",
     VARIANT_IDENTIFIER | VARIANT_NONE | VARIANT_ALL, // used only in shorthand
     nullptr)
 CSS_PROP_(
     transition-timing-function,
     transition_timing_function,
     TransitionTimingFunction,
+    0,
     "",
     VARIANT_KEYWORD | VARIANT_TIMING_FUNCTION, // used by list parsing
     kTransitionTimingFunctionKTable)
 CSS_PROP_(
     translate,
     translate,
     Translate,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "layout.css.individual-transform.enabled",
     0,
     nullptr)
 #ifndef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     unicode-bidi,
     unicode_bidi,
     UnicodeBidi,
+    0,
     "",
     VARIANT_HK,
     kUnicodeBidiKTable)
 #endif // CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 CSS_PROP_(
     -moz-user-focus,
     _moz_user_focus,
     CSS_PROP_DOMPROP_PREFIXED(UserFocus),
+    0,
     "",
     VARIANT_HK,
     kUserFocusKTable) // XXX bug 3935
 CSS_PROP_(
     -moz-user-input,
     _moz_user_input,
     CSS_PROP_DOMPROP_PREFIXED(UserInput),
+    0,
     "",
     VARIANT_HK,
     kUserInputKTable) // XXX ??? // XXX bug 3935
 CSS_PROP_(
     -moz-user-modify,
     _moz_user_modify,
     CSS_PROP_DOMPROP_PREFIXED(UserModify),
+    0,
     "",
     VARIANT_HK,
     kUserModifyKTable) // XXX bug 3935
 CSS_PROP_(
     -moz-user-select,
     _moz_user_select,
     CSS_PROP_DOMPROP_PREFIXED(UserSelect),
+    0,
     "",
     VARIANT_HK,
     kUserSelectKTable) // XXX bug 3935
 CSS_PROP_(
     vector-effect,
     vector_effect,
     VectorEffect,
+    0,
     "",
     VARIANT_HK,
     kVectorEffectKTable)
 // NOTE: vertical-align is only supposed to apply to :first-letter when
 // 'float' is 'none', but we don't worry about that since it has no
 // effect otherwise
 CSS_PROP_(
     vertical-align,
     vertical_align,
     VerticalAlign,
+    0,
     "",
     VARIANT_HKLP | VARIANT_CALC,
     kVerticalAlignKTable)
 CSS_PROP_(
     visibility,
     visibility,
     Visibility,
+    0,
     "",
     VARIANT_HK,
     kVisibilityKTable)  // reflow for collapse
 CSS_PROP_(
     white-space,
     white_space,
     WhiteSpace,
+    0,
     "",
     VARIANT_HK,
     kWhitespaceKTable)
 CSS_PROP_(
     width,
     width,
     Width,
+    CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     VARIANT_AHKLP | VARIANT_CALC,
     kWidthKTable)
 CSS_PROP_(
     will-change,
     will_change,
     WillChange,
+    0,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-window-dragging,
     _moz_window_dragging,
     CSS_PROP_DOMPROP_PREFIXED(WindowDragging),
+    0,
     "",
     VARIANT_HK,
     kWindowDraggingKTable)
 #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     -moz-window-opacity,
     _moz_window_opacity,
     CSS_PROP_DOMPROP_PREFIXED(WindowOpacity),
+    CSS_PROPERTY_INTERNAL,
     "",
     VARIANT_HN,
     nullptr)
 CSS_PROP_(
     -moz-window-shadow,
     _moz_window_shadow,
     CSS_PROP_DOMPROP_PREFIXED(WindowShadow),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS_AND_CHROME,
     "",
     VARIANT_HK,
     kWindowShadowKTable)
 CSS_PROP_(
     -moz-window-transform,
     _moz_window_transform,
     CSS_PROP_DOMPROP_PREFIXED(WindowTransform),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     0,
     nullptr)
 CSS_PROP_(
     -moz-window-transform-origin,
     _moz_window_transform_origin,
     CSS_PROP_DOMPROP_PREFIXED(WindowTransformOrigin),
+    CSS_PROPERTY_INTERNAL |
+        CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH,
     "",
     0,
     kImageLayerPositionKTable)
 #endif // CSS_PROP_LIST_EXCLUDE_INTERNAL
 CSS_PROP_(
     word-break,
     word_break,
     WordBreak,
+    0,
     "",
     VARIANT_HK,
     kWordBreakKTable)
 CSS_PROP_(
     word-spacing,
     word_spacing,
     WordSpacing,
+    0,
     "",
     VARIANT_HLP | VARIANT_NORMAL | VARIANT_CALC,
     nullptr)
 CSS_PROP_(
     writing-mode,
     writing_mode,
     WritingMode,
+    0,
     "",
     VARIANT_HK,
     kWritingModeKTable)
 CSS_PROP_(
     z-index,
     z_index,
     ZIndex,
+    0,
     "",
     VARIANT_AHI,
     nullptr)
 
 #undef CSS_PROP_
 
 #ifdef DEFINED_CSS_PROP_SHORTHAND
 #undef CSS_PROP_SHORTHAND
--- a/layout/style/nsCSSProps.cpp
+++ b/layout/style/nsCSSProps.cpp
@@ -28,16 +28,37 @@
 
 #include "mozilla/Preferences.h"
 #include "mozilla/StaticPrefs.h"
 
 using namespace mozilla;
 
 typedef nsCSSProps::KTableEntry KTableEntry;
 
+// By wrapping internal-only properties in this macro, we are not
+// exposing them in the CSSOM. Since currently it is not necessary to
+// allow accessing them in that way, it is easier and cheaper to just
+// do this rather than exposing them conditionally.
+#define CSS_PROP(name_, id_, method_, flags_, pref_, ...) \
+  static_assert(!((flags_) & CSS_PROPERTY_ENABLED_MASK) || pref_[0], \
+                "Internal-only property '" #name_ "' should be wrapped in " \
+                "#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL");
+#define CSS_PROP_LIST_EXCLUDE_INTERNAL
+#include "nsCSSPropList.h"
+#undef CSS_PROP_LIST_EXCLUDE_INTERNAL
+#undef CSS_PROP
+
+#define CSS_PROP(name_, id_, method_, flags_, pref_, ...) \
+  static_assert(!((flags_) & CSS_PROPERTY_ENABLED_IN_CHROME) || \
+                ((flags_) & CSS_PROPERTY_ENABLED_IN_UA_SHEETS), \
+                "Property '" #name_ "' is enabled in chrome, so it should " \
+                "also be enabled in UA sheets");
+#include "nsCSSPropList.h"
+#undef CSS_PROP
+
 // required to make the symbol external, so that TestCSSPropertyLookup.cpp can link with it
 extern const char* const kCSSRawProperties[];
 
 // define an array of all CSS properties
 const char* const kCSSRawProperties[eCSSProperty_COUNT_with_aliases] = {
 #define CSS_PROP_LONGHAND(name_, ...) #name_,
 #define CSS_PROP_SHORTHAND(name_, ...) #name_,
 #define CSS_PROP_ALIAS(name_, ...) #name_,
@@ -125,41 +146,42 @@ CreateStaticTable(const char* const aRaw
 }
 
 #ifdef DEBUG
 static void
 CheckServoCSSPropList()
 {
   struct PropData {
     nsCSSPropertyID mID;
+    uint32_t mFlags;
     const char* mPref;
   };
   const PropData sGeckoProps[eCSSProperty_COUNT_with_aliases] = {
-#define CSS_PROP(name_, id_, method_, pref_, ...) \
-    { eCSSProperty_##id_, pref_ },
+#define CSS_PROP(name_, id_, method_, flags_, pref_, ...) \
+    { eCSSProperty_##id_, flags_, pref_ },
 #include "nsCSSPropList.h"
 #undef CSS_PROP
 
-#define CSS_PROP_SHORTHAND(name_, id_, method_, pref_) \
-    { eCSSProperty_##id_, pref_ },
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
+    { eCSSProperty_##id_, flags_, pref_ },
 #include "nsCSSPropList.h"
 #undef CSS_PROP_SHORTHAND
 
 #define CSS_PROP_ALIAS(aliasname_, aliasid_, propid_, aliasmethod_, pref_) \
-    { eCSSPropertyAlias_##aliasid_, pref_ },
+    { eCSSPropertyAlias_##aliasid_, 0, pref_ },
 #include "nsCSSPropAliasList.h"
 #undef CSS_PROP_ALIAS
   };
   const PropData sServoProps[eCSSProperty_COUNT_with_aliases] = {
 #define CSS_PROP_LONGHAND(name_, id_, method_, flags_, pref_) \
-    { eCSSProperty_##id_, pref_ },
+    { eCSSProperty_##id_, flags_, pref_ },
 #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
-    { eCSSProperty_##id_, pref_ },
+    { eCSSProperty_##id_, flags_, pref_ },
 #define CSS_PROP_ALIAS(name_, aliasid_, id_, method_, pref_) \
-    { eCSSPropertyAlias_##aliasid_, pref_ },
+    { eCSSPropertyAlias_##aliasid_, 0, pref_ },
 #include "mozilla/ServoCSSPropList.h"
 #undef CSS_PROP_ALIAS
 #undef CSS_PROP_SHORTHAND
 #undef CSS_PROP_LONGHAND
   };
 
   bool mismatch = false;
   for (size_t i = 0; i < eCSSProperty_COUNT_with_aliases; i++) {
@@ -167,16 +189,20 @@ CheckServoCSSPropList()
     auto& servoData = sServoProps[i];
     const char* name = nsCSSProps::GetStringValue(geckoData.mID).get();
     if (geckoData.mID != servoData.mID) {
       printf_stderr("Order mismatches: gecko: %s, servo: %s\n",
                     name, nsCSSProps::GetStringValue(servoData.mID).get());
       mismatch = true;
       continue;
     }
+    if (geckoData.mFlags != servoData.mFlags) {
+      printf_stderr("Flags of %s mismatch\n", name);
+      mismatch = true;
+    }
     if (strcmp(geckoData.mPref, servoData.mPref) != 0) {
       printf_stderr("Pref of %s mismatches\n", name);
       mismatch = true;
     }
   }
 
   const nsCSSPropertyID sGeckoAliases[eCSSAliasCount] = {
 #define CSS_PROP_ALIAS(aliasname_, aliasid_, propid_, aliasmethod_, pref_) \
@@ -250,16 +276,81 @@ nsCSSProps::AddRefTable(void)
         OBSERVE_PROP(pref_, eCSSPropertyAlias_##aliasid_)
       #include "mozilla/ServoCSSPropList.h"
       #undef CSS_PROP_ALIAS
       #undef CSS_PROP_SHORTHAND
       #undef CSS_PROP_LONGHAND
 
       #undef OBSERVE_PROP
     }
+
+#ifdef DEBUG
+    {
+      // Assert that if CSS_PROPERTY_ENABLED_IN_UA_SHEETS or
+      // CSS_PROPERTY_ENABLED_IN_CHROME is used on a shorthand property
+      // that all of its component longhands also have the flag.
+      static uint32_t flagsToCheck[] = {
+        CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
+        CSS_PROPERTY_ENABLED_IN_CHROME
+      };
+      for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+           shorthand < eCSSProperty_COUNT;
+           shorthand = nsCSSPropertyID(shorthand + 1)) {
+        for (size_t i = 0; i < ArrayLength(flagsToCheck); i++) {
+          uint32_t flag = flagsToCheck[i];
+          if (!nsCSSProps::PropHasFlags(shorthand, flag)) {
+            continue;
+          }
+          for (const nsCSSPropertyID* p =
+                 nsCSSProps::SubpropertyEntryFor(shorthand);
+               *p != eCSSProperty_UNKNOWN;
+               ++p) {
+            MOZ_ASSERT(nsCSSProps::PropHasFlags(*p, flag),
+                       "all subproperties of a property with a "
+                       "CSS_PROPERTY_ENABLED_* flag must also have "
+                       "the flag");
+          }
+        }
+      }
+
+      // Assert that CSS_PROPERTY_INTERNAL is used on properties in
+      // #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL sections of nsCSSPropList.h
+      // and on no others.
+      static nsCSSPropertyID nonInternalProperties[] = {
+        #define CSS_PROP(name_, id_, ...)           eCSSProperty_##id_,
+        #define CSS_PROP_SHORTHAND(name_, id_, ...) eCSSProperty_##id_,
+        #define CSS_PROP_LIST_EXCLUDE_INTERNAL
+        #include "nsCSSPropList.h"
+        #undef CSS_PROP_LIST_EXCLUDE_INTERNAL
+        #undef CSS_PROP_SHORTHAND
+        #undef CSS_PROP
+      };
+      MOZ_ASSERT(ArrayLength(nonInternalProperties) <= eCSSProperty_COUNT);
+
+      bool found[eCSSProperty_COUNT];
+      PodArrayZero(found);
+      for (nsCSSPropertyID p : nonInternalProperties) {
+        MOZ_ASSERT(!nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
+                   "properties defined outside of #ifndef "
+                   "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must not have "
+                   "the CSS_PROPERTY_INTERNAL flag");
+        found[p] = true;
+      }
+
+      for (size_t i = 0; i < ArrayLength(found); ++i) {
+        if (!found[i]) {
+          auto p = static_cast<nsCSSPropertyID>(i);
+          MOZ_ASSERT(nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
+                     "properties defined in #ifndef "
+                     "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must have "
+                     "the CSS_PROPERTY_INTERNAL flag");
+        }
+      }
+    }
+#endif
   }
 }
 
 #undef  DEBUG_SHORTHANDS_CONTAINING
 
 void
 nsCSSProps::ReleaseTable(void)
 {
@@ -2209,17 +2300,17 @@ nsCSSProps::ValueToKeyword(int32_t aValu
     return sNullStr;
   } else {
     return nsCSSKeywords::GetStringValue(keyword);
   }
 }
 
 /* static */ const KTableEntry* const
 nsCSSProps::kKeywordTableTable[eCSSProperty_COUNT_no_shorthands] = {
-  #define CSS_PROP(name_, id_, method_, pref_, parsevariant_, \
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, \
                    kwtable_) kwtable_,
   #include "nsCSSPropList.h"
   #undef CSS_PROP
 };
 
 const nsCString&
 nsCSSProps::LookupPropertyValue(nsCSSPropertyID aProp, int32_t aValue)
 {
@@ -2253,17 +2344,17 @@ bool nsCSSProps::GetColorName(int32_t aP
     nsCSSKeywords::AddRefTable();
     aStr = nsCSSKeywords::GetStringValue(keyword);
     nsCSSKeywords::ReleaseTable();
     rv = true;
   }
   return rv;
 }
 
-const CSSPropFlags nsCSSProps::kFlagsTable[eCSSProperty_COUNT] = {
+const uint32_t nsCSSProps::kFlagsTable[eCSSProperty_COUNT] = {
 #define CSS_PROP_LONGHAND(name_, id_, method_, flags_, ...) flags_,
 #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, ...) flags_,
 #include "mozilla/ServoCSSPropList.h"
 #undef CSS_PROP_SHORTHAND
 #undef CSS_PROP_LONGHAND
 };
 
 static const nsCSSPropertyID gAllSubpropTable[] = {
@@ -2699,33 +2790,33 @@ static const nsCSSPropertyID gMaskPositi
 // mask-border properties.
 
 const nsCSSPropertyID *const
 nsCSSProps::kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands] = {
 #define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
 // Need an extra level of macro nesting to force expansion of method_
 // params before they get pasted.
 #define NSCSSPROPS_INNER_MACRO(method_) g##method_##SubpropTable,
-#define CSS_PROP_SHORTHAND(name_, id_, method_, pref_) \
+#define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
   NSCSSPROPS_INNER_MACRO(method_)
 #include "nsCSSPropList.h"
 #undef CSS_PROP_SHORTHAND
 #undef NSCSSPROPS_INNER_MACRO
 #undef CSS_PROP_PUBLIC_OR_PRIVATE
 };
 
 /* static */ bool
 nsCSSProps::gPropertyEnabled[eCSSProperty_COUNT_with_aliases] = {
   // If the property has any "ENABLED_IN" flag set, it is disabled by
   // default. Note that, if a property has pref, whatever its default
   // value is, it will later be changed in nsCSSProps::AddRefTable().
   // If the property has "ENABLED_IN" flags but doesn't have a pref,
   // it is an internal property which is disabled elsewhere.
   #define IS_ENABLED_BY_DEFAULT(flags_) \
-    (!((flags_) & (CSSPropFlags::EnabledMask | CSSPropFlags::Inaccessible)))
+    (!((flags_) & (CSS_PROPERTY_ENABLED_MASK | CSS_PROPERTY_PARSE_INACCESSIBLE)))
 
   #define CSS_PROP_LONGHAND(name_, id_, method_, flags_, ...) \
     IS_ENABLED_BY_DEFAULT(flags_),
   #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, ...) \
     IS_ENABLED_BY_DEFAULT(flags_),
   #define CSS_PROP_ALIAS(...) true,
   #include "mozilla/ServoCSSPropList.h"
   #undef CSS_PROP_ALIAS
@@ -2749,15 +2840,15 @@ nsCSSProps::gPropertyUseCounter[eCSSProp
   #include "mozilla/ServoCSSPropList.h"
   #undef CSS_PROP_LONGHAND
   #undef CSS_PROP_USE_COUNTER
   #undef CSS_PROP_PUBLIC_OR_PRIVATE
 };
 
 const uint32_t
 nsCSSProps::kParserVariantTable[eCSSProperty_COUNT_no_shorthands] = {
-#define CSS_PROP(name_, id_, method_, pref_, parsevariant_, ...) \
+#define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, ...) \
   parsevariant_,
 #include "nsCSSPropList.h"
 #undef CSS_PROP
 };
 
 #include "nsCSSPropsGenerated.inc"
--- a/layout/style/nsCSSProps.h
+++ b/layout/style/nsCSSProps.h
@@ -14,17 +14,16 @@
 
 #include <limits>
 #include <type_traits>
 #include "nsStringFwd.h"
 #include "nsCSSPropertyID.h"
 #include "nsStyleStructFwd.h"
 #include "nsCSSKeywords.h"
 #include "mozilla/CSSEnabledState.h"
-#include "mozilla/CSSPropFlags.h"
 #include "mozilla/UseCounter.h"
 #include "mozilla/EnumTypeTraits.h"
 #include "mozilla/Preferences.h"
 #include "nsXULAppAPI.h"
 
 // Length of the "--" prefix on custom names (such as custom property names,
 // and, in the future, custom media query names).
 #define CSS_CUSTOM_NAME_PREFIX_LENGTH 2
@@ -118,20 +117,63 @@
 #define VARIANT_LBCALC (VARIANT_LB | VARIANT_CALC)
 #define VARIANT_LCALC  (VARIANT_LENGTH | VARIANT_CALC)
 #define VARIANT_LPCALC (VARIANT_LCALC | VARIANT_PERCENT)
 #define VARIANT_LNCALC (VARIANT_LCALC | VARIANT_NUMBER)
 #define VARIANT_LPNCALC (VARIANT_LNCALC | VARIANT_PERCENT)
 #define VARIANT_IMAGE   (VARIANT_URL | VARIANT_NONE | VARIANT_GRADIENT | \
                         VARIANT_IMAGE_RECT | VARIANT_ELEMENT)
 
+// Flags for the kFlagsTable bitfield (flags_ in nsCSSPropList.h)
+
+// Define what mechanism the CSS parser uses for parsing the property.
+// See CSSParserImpl::ParseProperty(nsCSSPropertyID).  Don't use 0 so that
+// we can verify that every property sets one of the values.
+#define CSS_PROPERTY_PARSE_PROPERTY_MASK          (7<<9)
+#define CSS_PROPERTY_PARSE_INACCESSIBLE           (1<<9)
+
+// There's a free bit here.
+
+// This property's getComputedStyle implementation requires layout to be
+// flushed.
+#define CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH     (1<<20)
+
+// The following two flags along with the pref defines where the this
+// property can be used:
+// * If none of the two flags is presented, the pref completely controls
+//   the availability of this property. And in that case, if it has no
+//   pref, this property is usable everywhere.
+// * If any of the flags is set, this property is always enabled in the
+//   specific contexts regardless of the value of the pref. If there is
+//   no pref for this property at all in this case, it is an internal-
+//   only property, which cannot be used anywhere else, and should be
+//   wrapped in "#ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL".
+// Note that, these flags have no effect on the use of aliases of this
+// property.
+// Furthermore, for the purposes of animation (including triggering
+// transitions) these flags are ignored. That is, if the property is disabled
+// by a pref, we will *not* run animations or transitions on it even in
+// UA sheets or chrome.
+#define CSS_PROPERTY_ENABLED_MASK                 (3<<22)
+#define CSS_PROPERTY_ENABLED_IN_UA_SHEETS         (1<<22)
+#define CSS_PROPERTY_ENABLED_IN_CHROME            (1<<23)
+#define CSS_PROPERTY_ENABLED_IN_UA_SHEETS_AND_CHROME \
+  (CSS_PROPERTY_ENABLED_IN_UA_SHEETS | CSS_PROPERTY_ENABLED_IN_CHROME)
+
+// This property can be animated on the compositor.
+#define CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR    (1<<27)
+
+// This property is an internal property that is not represented
+// in the DOM.  Properties with this flag must be defined in an #ifndef
+// CSS_PROP_LIST_EXCLUDE_INTERNAL section of nsCSSPropList.h.
+#define CSS_PROPERTY_INTERNAL                     (1<<28)
+
 class nsCSSProps {
 public:
   typedef mozilla::CSSEnabledState EnabledState;
-  typedef mozilla::CSSPropFlags Flags;
 
   struct KTableEntry
   {
     // KTableEntry objects can be initialized either with an int16_t value
     // or a value of an enumeration type that can fit within an int16_t.
 
     constexpr KTableEntry(nsCSSKeyword aKeyword, int16_t aValue)
       : mKeyword(aKeyword)
@@ -235,26 +277,38 @@ public:
     static_assert(mozilla::EnumTypeFitsWithin<T, int16_t>::value,
                   "aValue must be an enum that fits within KTableEntry::mValue");
     return ValueToKeyword(static_cast<int16_t>(aValue), aTable);
   }
 
   static const KTableEntry* const kKeywordTableTable[eCSSProperty_COUNT_no_shorthands];
 
 private:
-  static const Flags kFlagsTable[eCSSProperty_COUNT];
+  static const uint32_t        kFlagsTable[eCSSProperty_COUNT];
 
 public:
-  static inline bool PropHasFlags(nsCSSPropertyID aProperty, Flags aFlags)
+  static inline bool PropHasFlags(nsCSSPropertyID aProperty, uint32_t aFlags)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
+    MOZ_ASSERT(!(aFlags & CSS_PROPERTY_PARSE_PROPERTY_MASK),
+               "The CSS_PROPERTY_PARSE_* values are not bitflags; don't pass "
+               "them to PropHasFlags.  You probably want PropertyParseType "
+               "instead.");
     return (nsCSSProps::kFlagsTable[aProperty] & aFlags) == aFlags;
   }
 
+  static inline uint32_t PropertyParseType(nsCSSPropertyID aProperty)
+  {
+    MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
+               "out of range");
+    return nsCSSProps::kFlagsTable[aProperty] &
+           CSS_PROPERTY_PARSE_PROPERTY_MASK;
+  }
+
 private:
   static const uint32_t kParserVariantTable[eCSSProperty_COUNT_no_shorthands];
 
 public:
   static inline uint32_t ParserVariant(nsCSSPropertyID aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
                "out of range");
     return nsCSSProps::kParserVariantTable[aProperty];
@@ -343,22 +397,22 @@ public:
   {
     if (IsEnabled(aProperty)) {
       return true;
     }
     if (aEnabled == EnabledState::eIgnoreEnabledState) {
       return true;
     }
     if ((aEnabled & EnabledState::eInUASheets) &&
-        PropHasFlags(aProperty, Flags::EnabledInUASheets))
+        PropHasFlags(aProperty, CSS_PROPERTY_ENABLED_IN_UA_SHEETS))
     {
       return true;
     }
     if ((aEnabled & EnabledState::eInChrome) &&
-        PropHasFlags(aProperty, Flags::EnabledInChrome))
+        PropHasFlags(aProperty, CSS_PROPERTY_ENABLED_IN_CHROME))
     {
       return true;
     }
     return false;
   }
 
 public:
 
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -15,16 +15,17 @@
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/ServoTypes.h"
 #include "mozilla/SheetType.h"
 #include "mozilla/URLExtraData.h"
 #include "mozilla/UniquePtr.h"
 
 #include "nsCSSKeywords.h"
 #include "nsCSSPropertyID.h"
+#include "nsCSSProps.h"
 #include "nsCoord.h"
 #include "nsProxyRelease.h"
 #include "nsRefPtrHashtable.h"
 #include "nsString.h"
 #include "nsStringBuffer.h"
 #include "nsTArray.h"
 #include "nsStyleConsts.h"
 #include "nsStyleCoord.h"
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -181,17 +181,17 @@ struct ComputedStyleMap
     typedef already_AddRefed<CSSValue> (nsComputedDOMStyle::*ComputeMethod)();
 
     nsCSSPropertyID mProperty;
     ComputeMethod mGetter;
 
     bool IsLayoutFlushNeeded() const
     {
       return nsCSSProps::PropHasFlags(mProperty,
-                                      CSSPropFlags::GetCSNeedsLayoutFlush);
+                                      CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH);
     }
 
     bool IsEnabled() const
     {
       return nsCSSProps::IsEnabled(mProperty, CSSEnabledState::eForAllContent);
     }
   };
 
--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -74,17 +74,17 @@ ElementPropertyTransition::CurrentValueP
 
 void
 ElementPropertyTransition::UpdateStartValueFromReplacedTransition()
 {
   if (!mReplacedTransition) {
     return;
   }
   MOZ_ASSERT(nsCSSProps::PropHasFlags(TransitionProperty(),
-                                      CSSPropFlags::CanAnimateOnCompositor),
+                                      CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "The transition property should be able to be run on the "
              "compositor");
   MOZ_ASSERT(mTarget && mTarget->mElement->OwnerDoc(),
              "We should have a valid document at this moment");
 
   dom::DocumentTimeline* timeline = mTarget->mElement->OwnerDoc()->Timeline();
   ComputedTiming computedTiming = GetComputedTimingAt(
     dom::CSSTransition::GetCurrentTimeAt(*timeline,