Bug 1497734 - Rename nsStaticAtom subclasses. r=heycam
authorNicholas Nethercote <nnethercote@mozilla.com>
Wed, 10 Oct 2018 16:49:13 +1100
changeset 496233 3924e39ce03a0004287b06dc478b90d257e1dd45
parent 496232 8d392a740646e3e7e2e173c97b70fc19ba121e21
child 496234 8af8ea2d88b0159cce6e59317d0a4adf7b5b5bf0
push id9984
push userffxbld-merge
push dateMon, 15 Oct 2018 21:07:35 +0000
treeherdermozilla-beta@183d27ea8570 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersheycam
bugs1497734
milestone64.0a1
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
Bug 1497734 - Rename nsStaticAtom subclasses. r=heycam Specifically: - nsICSSAnonBoxPseudo --> nsCSSAnonBoxPseudoStaticAtom - nsICSSPseudoElement --> nsCSSPseudoElementStaticAtom The `nsI` prefix isn't necessary because these are no longer XPIDL types, and the `StaticAtom` suffix makes their meaning clearer.
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsCSSFrameConstructor.h
layout/style/ServoStyleSet.cpp
layout/style/ServoStyleSet.h
layout/style/nsCSSAnonBoxes.h
layout/style/nsCSSPseudoElements.h
layout/xul/tree/nsTreeBodyFrame.cpp
layout/xul/tree/nsTreeBodyFrame.h
layout/xul/tree/nsTreeStyleCache.cpp
layout/xul/tree/nsTreeStyleCache.h
servo/components/style/gecko/regen_atoms.py
xpcom/ds/Atom.py
xpcom/ds/nsAtom.h
xpcom/ds/nsGkAtoms.h
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -4955,17 +4955,17 @@ nsCSSFrameConstructor::FindMathMLData(co
 nsContainerFrame*
 nsCSSFrameConstructor::ConstructFrameWithAnonymousChild(
                                    nsFrameConstructorState& aState,
                                    FrameConstructionItem&   aItem,
                                    nsContainerFrame*        aParentFrame,
                                    nsFrameItems&            aFrameItems,
                                    ContainerFrameCreationFunc aConstructor,
                                    ContainerFrameCreationFunc aInnerConstructor,
-                                   nsICSSAnonBoxPseudo*     aInnerPseudo,
+                                   nsCSSAnonBoxPseudoStaticAtom* aInnerPseudo,
                                    bool                     aCandidateRootFrame)
 {
   nsIContent* const content = aItem.mContent;
   ComputedStyle* const computedStyle = aItem.mComputedStyle;
 
   // Create the outer frame:
   nsContainerFrame* newFrame = aConstructor(mPresShell, computedStyle);
 
@@ -9775,17 +9775,17 @@ nsCSSFrameConstructor::CreateNeededPseud
 void
 nsCSSFrameConstructor::WrapItemsInPseudoParent(nsIContent* aParentContent,
                                                ComputedStyle* aParentStyle,
                                                ParentType aWrapperType,
                                                FCItemIterator& aIter,
                                                const FCItemIterator& aEndIter)
 {
   const PseudoParentData& pseudoData = sPseudoParentData[aWrapperType];
-  nsICSSAnonBoxPseudo* pseudoType = pseudoData.mPseudoType;
+  nsCSSAnonBoxPseudoStaticAtom* pseudoType = pseudoData.mPseudoType;
   StyleDisplay parentDisplay = aParentStyle->StyleDisplay()->mDisplay;
 
   if (pseudoType == nsCSSAnonBoxes::table() &&
       (parentDisplay == StyleDisplay::Inline ||
        parentDisplay == StyleDisplay::RubyBase ||
        parentDisplay == StyleDisplay::RubyText)) {
     pseudoType = nsCSSAnonBoxes::inlineTable();
   }
--- a/layout/base/nsCSSFrameConstructor.h
+++ b/layout/base/nsCSSFrameConstructor.h
@@ -28,17 +28,17 @@
 
 struct nsFrameItems;
 struct nsStyleDisplay;
 struct nsGenConInitializer;
 
 class nsContainerFrame;
 class nsFirstLineFrame;
 class nsFirstLetterFrame;
-class nsICSSAnonBoxPseudo;
+class nsCSSAnonBoxPseudoStaticAtom;
 class nsIDocument;
 class nsPageContentFrame;
 struct PendingBinding;
 
 class nsFrameConstructorState;
 
 namespace mozilla {
 
@@ -737,17 +737,17 @@ private:
     // FrameFullConstructor to see what the functions would do.
     union Func {
       FrameCreationFunc mCreationFunc;
       FrameConstructionDataGetter mDataGetter;
     } mFunc;
     FrameFullConstructor mFullConstructor;
     // For cases when FCDATA_CREATE_BLOCK_WRAPPER_FOR_ALL_KIDS is set, the
     // anonymous box type to use for that wrapper.
-    nsICSSAnonBoxPseudo* const mAnonBoxPseudo;
+    nsCSSAnonBoxPseudoStaticAtom* const mAnonBoxPseudo;
   };
 
   /* Structure representing a mapping of an atom to a FrameConstructionData.
      This can be used with non-static atoms, assuming that the nsAtom* is
      stored somewhere that this struct can point to (that is, a static
      nsAtom*) and that it's allocated before the struct is ever used. */
   struct FrameConstructionDataByTag {
     const nsStaticAtom* const mTag;
@@ -776,17 +776,17 @@ private:
 #define FCDATA_FOR_DISPLAY(_display, _fcdata) \
   { _fcdata }
 #endif
 
   /* Structure that has a FrameConstructionData and style pseudo-type
      for a table pseudo-frame */
   struct PseudoParentData {
     const FrameConstructionData mFCData;
-    nsICSSAnonBoxPseudo* const mPseudoType;
+    nsCSSAnonBoxPseudoStaticAtom* const mPseudoType;
   };
   /* Array of such structures that we use to properly construct table
      pseudo-frames as needed */
   static const PseudoParentData sPseudoParentData[eParentTypeCount];
 
   // The information that concerns the frame constructor after loading an XBL
   // binding.
   //
@@ -1581,17 +1581,17 @@ private:
    */
   nsContainerFrame* ConstructFrameWithAnonymousChild(
                                   nsFrameConstructorState& aState,
                                   FrameConstructionItem&   aItem,
                                   nsContainerFrame*        aParentFrame,
                                   nsFrameItems&            aFrameItems,
                                   ContainerFrameCreationFunc aConstructor,
                                   ContainerFrameCreationFunc aInnerConstructor,
-                                  nsICSSAnonBoxPseudo*     aInnerPseudo,
+                                  nsCSSAnonBoxPseudoStaticAtom* aInnerPseudo,
                                   bool                     aCandidateRootFrame);
 
   /**
    * Construct an nsSVGOuterSVGFrame.
    */
   nsIFrame* ConstructOuterSVG(nsFrameConstructorState& aState,
                               FrameConstructionItem&   aItem,
                               nsContainerFrame*        aParentFrame,
--- a/layout/style/ServoStyleSet.cpp
+++ b/layout/style/ServoStyleSet.cpp
@@ -668,17 +668,17 @@ ServoStyleSet::ResolveNonInheritingAnony
 
   cache = computedValues;
   return computedValues.forget();
 }
 
 #ifdef MOZ_XUL
 already_AddRefed<ComputedStyle>
 ServoStyleSet::ResolveXULTreePseudoStyle(dom::Element* aParentElement,
-                                         nsICSSAnonBoxPseudo* aPseudoTag,
+                                         nsCSSAnonBoxPseudoStaticAtom* aPseudoTag,
                                          ComputedStyle* aParentContext,
                                          const AtomArray& aInputWord)
 {
   MOZ_ASSERT(nsCSSAnonBoxes::IsTreePseudoElement(aPseudoTag));
   MOZ_ASSERT(aParentContext);
   MOZ_ASSERT(!StylistNeedsUpdate());
 
   return Servo_ComputedValues_ResolveXULTreePseudoStyle(
--- a/layout/style/ServoStyleSet.h
+++ b/layout/style/ServoStyleSet.h
@@ -216,17 +216,17 @@ public:
   // anything.  aPseudoTag is the pseudo-tag to use and must be non-null.  It
   // must be an anon box, and must be a non-inheriting one.
   already_AddRefed<ComputedStyle>
   ResolveNonInheritingAnonymousBoxStyle(nsAtom* aPseudoTag);
 
 #ifdef MOZ_XUL
   already_AddRefed<ComputedStyle>
   ResolveXULTreePseudoStyle(dom::Element* aParentElement,
-                            nsICSSAnonBoxPseudo* aPseudoTag,
+                            nsCSSAnonBoxPseudoStaticAtom* aPseudoTag,
                             ComputedStyle* aParentContext,
                             const AtomArray& aInputWord);
 #endif
 
   // manage the set of style sheets in the style set
   nsresult AppendStyleSheet(SheetType aType, StyleSheet* aSheet);
   nsresult PrependStyleSheet(SheetType aType, StyleSheet* aSheet);
   nsresult RemoveStyleSheet(SheetType aType, StyleSheet* aSheet);
--- a/layout/style/nsCSSAnonBoxes.h
+++ b/layout/style/nsCSSAnonBoxes.h
@@ -89,21 +89,21 @@ public:
   // Get the NonInheriting type for a given pseudo tag.  The pseudo tag must
   // test true for IsNonInheritingAnonBox.
   static NonInheriting NonInheritingTypeForPseudoTag(nsAtom* aPseudo);
 
 #ifdef DEBUG
   static void AssertAtoms();
 #endif
 
-  // Alias nsCSSAnonBoxes::foo() to alias nsGkAtoms::AnonBox_foo.
+  // Alias nsCSSAnonBoxes::foo() to nsGkAtoms::AnonBox_foo.
   #define CSS_ANON_BOX(name_, value_)                     \
-    static nsICSSAnonBoxPseudo* name_()                   \
+    static nsCSSAnonBoxPseudoStaticAtom* name_()          \
     {                                                     \
-      return const_cast<nsICSSAnonBoxPseudo*>(            \
-        static_cast<const nsICSSAnonBoxPseudo*>(          \
+      return const_cast<nsCSSAnonBoxPseudoStaticAtom*>(   \
+        static_cast<const nsCSSAnonBoxPseudoStaticAtom*>( \
           nsGkAtoms::AnonBox_##name_));                   \
     }
   #include "nsCSSAnonBoxList.h"
   #undef CSS_ANON_BOX
 };
 
 #endif /* nsCSSAnonBoxes_h___ */
--- a/layout/style/nsCSSPseudoElements.h
+++ b/layout/style/nsCSSPseudoElements.h
@@ -98,22 +98,22 @@ public:
     return PseudoElementHasFlags(aType, CSS_PSEUDO_ELEMENT_IS_CSS2);
   }
 
 public:
 #ifdef DEBUG
   static void AssertAtoms();
 #endif
 
-  // Alias nsCSSPseudoElements::foo() to alias nsGkAtoms::foo.
+  // Alias nsCSSPseudoElements::foo() to nsGkAtoms::foo.
   #define CSS_PSEUDO_ELEMENT(name_, value_, flags_)       \
-    static nsICSSPseudoElement* name_()                   \
+    static nsCSSPseudoElementStaticAtom* name_()          \
     {                                                     \
-      return const_cast<nsICSSPseudoElement*>(            \
-        static_cast<const nsICSSPseudoElement*>(          \
+      return const_cast<nsCSSPseudoElementStaticAtom*>(   \
+        static_cast<const nsCSSPseudoElementStaticAtom*>( \
           nsGkAtoms::PseudoElement_##name_));             \
     }
   #include "nsCSSPseudoElementList.h"
   #undef CSS_PSEUDO_ELEMENT
 
   static Type GetPseudoType(nsAtom* aAtom, EnabledState aEnabledState);
 
   // Get the atom for a given Type. aType must be < CSSPseudoElementType::Count.
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -989,17 +989,17 @@ nsTreeBodyFrame::GetCellAt(int32_t aX, i
 
   // Check if the coordinates are above our visible space.
   if (point.y < 0) {
     *aRow = -1;
     return NS_OK;
   }
 
   nsTreeColumn* col;
-  nsICSSAnonBoxPseudo* child;
+  nsCSSAnonBoxPseudoStaticAtom* child;
   GetCellAt(point.x, point.y, aRow, &col, &child);
 
   if (col) {
     NS_ADDREF(*aCol = col);
     if (child == nsCSSAnonBoxes::mozTreeCell())
       aChildElt.AssignLiteral("cell");
     else if (child == nsCSSAnonBoxes::mozTreeTwisty())
       aChildElt.AssignLiteral("twisty");
@@ -1419,17 +1419,17 @@ nsTreeBodyFrame::AdjustForCellText(nsAut
       aTextRect.x += (aTextRect.width - width) / 2;
     }
     break;
   }
 
   aTextRect.width = width;
 }
 
-nsICSSAnonBoxPseudo*
+nsCSSAnonBoxPseudoStaticAtom*
 nsTreeBodyFrame::GetItemWithinCellAt(nscoord aX, const nsRect& aCellRect,
                                      int32_t aRowIndex,
                                      nsTreeColumn* aColumn)
 {
   MOZ_ASSERT(aColumn && aColumn->GetFrame(), "invalid column passed");
 
   // Obtain the properties for our cell.
   PrefillPropertyArray(aRowIndex, aColumn);
@@ -1570,17 +1570,17 @@ nsTreeBodyFrame::GetItemWithinCellAt(nsc
     return nsCSSAnonBoxes::mozTreeCellText();
   else
     return nsCSSAnonBoxes::mozTreeCell();
 }
 
 void
 nsTreeBodyFrame::GetCellAt(nscoord aX, nscoord aY, int32_t* aRow,
                            nsTreeColumn** aCol,
-                           nsICSSAnonBoxPseudo** aChildElt)
+                           nsCSSAnonBoxPseudoStaticAtom** aChildElt)
 {
   *aCol = nullptr;
   *aChildElt = nullptr;
 
   *aRow = GetRowAtInternal(aX, aY);
   if (*aRow < 0)
     return;
 
@@ -2432,17 +2432,17 @@ nsTreeBodyFrame::GetCursor(const nsPoint
                            nsIFrame::Cursor& aCursor)
 {
   // Check the GetScriptHandlingObject so we don't end up running code when
   // the document is a zombie.
   bool dummy;
   if (mView && GetContent()->GetComposedDoc()->GetScriptHandlingObject(dummy)) {
     int32_t row;
     nsTreeColumn* col;
-    nsICSSAnonBoxPseudo* child;
+    nsCSSAnonBoxPseudoStaticAtom* child;
     GetCellAt(aPoint.x, aPoint.y, &row, &col, &child);
 
     if (child) {
       // Our scratch array is already prefilled.
       ComputedStyle* childContext = GetPseudoComputedStyle(child);
 
       FillCursorInformationFromStyle(childContext->StyleUI(), aCursor);
       if (aCursor.mCursor == NS_STYLE_CURSOR_AUTO)
@@ -4195,17 +4195,18 @@ nsTreeBodyFrame::ThumbMoved(nsScrollbarF
   }
   if (weakFrame.IsAlive()) {
     UpdateScrollbars(parts);
   }
 }
 
 // The style cache.
 ComputedStyle*
-nsTreeBodyFrame::GetPseudoComputedStyle(nsICSSAnonBoxPseudo* aPseudoElement)
+nsTreeBodyFrame::GetPseudoComputedStyle(
+  nsCSSAnonBoxPseudoStaticAtom* aPseudoElement)
 {
   return mStyleCache.GetComputedStyle(PresContext(), mContent,
                                       mComputedStyle, aPseudoElement,
                                       mScratchArray);
 }
 
 Element*
 nsTreeBodyFrame::GetBaseElement()
--- a/layout/xul/tree/nsTreeBodyFrame.h
+++ b/layout/xul/tree/nsTreeBodyFrame.h
@@ -309,25 +309,25 @@ protected:
   void AdjustForCellText(nsAutoString& aText,
                          int32_t aRowIndex,
                          nsTreeColumn* aColumn,
                          gfxContext& aRenderingContext,
                          nsFontMetrics& aFontMetrics,
                          nsRect& aTextRect);
 
   // A helper used when hit testing.
-  nsICSSAnonBoxPseudo* GetItemWithinCellAt(nscoord aX,
-                                           const nsRect& aCellRect,
-                                           int32_t aRowIndex,
-                                           nsTreeColumn* aColumn);
+  nsCSSAnonBoxPseudoStaticAtom* GetItemWithinCellAt(nscoord aX,
+                                                    const nsRect& aCellRect,
+                                                    int32_t aRowIndex,
+                                                    nsTreeColumn* aColumn);
 
   // An internal hit test.  aX and aY are expected to be in twips in the
   // coordinate system of this frame.
   void GetCellAt(nscoord aX, nscoord aY, int32_t* aRow, nsTreeColumn** aCol,
-                 nsICSSAnonBoxPseudo** aChildElt);
+                 nsCSSAnonBoxPseudoStaticAtom** aChildElt);
 
   // Retrieve the area for the twisty for a cell.
   nsITheme* GetTwistyRect(int32_t aRowIndex,
                           nsTreeColumn* aColumn,
                           nsRect& aImageRect,
                           nsRect& aTwistyRect,
                           nsPresContext* aPresContext,
                           ComputedStyle* aTwistyContext);
@@ -355,17 +355,18 @@ protected:
   // Calculates our width/height once border and padding have been removed.
   void CalcInnerBox();
 
   // Calculate the total width of our scrollable portion
   nscoord CalcHorzWidth(const ScrollParts& aParts);
 
   // Looks up a ComputedStyle in the style cache.  On a cache miss we resolve
   // the pseudo-styles passed in and place them into the cache.
-  ComputedStyle* GetPseudoComputedStyle(nsICSSAnonBoxPseudo* aPseudoElement);
+  ComputedStyle* GetPseudoComputedStyle(
+    nsCSSAnonBoxPseudoStaticAtom* aPseudoElement);
 
   // Retrieves the scrollbars and scrollview relevant to this treebody. We
   // traverse the frame tree under our base element, in frame order, looking
   // for the first relevant vertical scrollbar, horizontal scrollbar, and
   // scrollable frame (with associated content and scrollable view). These
   // are all volatile and should not be retained.
   ScrollParts GetScrollParts();
 
--- a/layout/xul/tree/nsTreeStyleCache.cpp
+++ b/layout/xul/tree/nsTreeStyleCache.cpp
@@ -31,17 +31,17 @@ nsTreeStyleCache::Transition::Hash() con
 }
 
 
 // The ComputedStyle cache impl
 ComputedStyle*
 nsTreeStyleCache::GetComputedStyle(nsPresContext* aPresContext,
                                    nsIContent* aContent,
                                    ComputedStyle* aStyle,
-                                   nsICSSAnonBoxPseudo* aPseudoElement,
+                                   nsCSSAnonBoxPseudoStaticAtom* aPseudoElement,
                                    const AtomArray & aInputWord)
 {
   MOZ_ASSERT(nsCSSAnonBoxes::IsTreePseudoElement(aPseudoElement));
 
   uint32_t count = aInputWord.Length();
 
   // Go ahead and init the transition table.
   if (!mTransitionTable) {
--- a/layout/xul/tree/nsTreeStyleCache.h
+++ b/layout/xul/tree/nsTreeStyleCache.h
@@ -33,17 +33,17 @@ public:
     mCache = nullptr;
     mNextState = 0;
   }
 
   mozilla::ComputedStyle* GetComputedStyle(
       nsPresContext* aPresContext,
       nsIContent* aContent,
       mozilla::ComputedStyle* aStyle,
-      nsICSSAnonBoxPseudo* aPseudoElement,
+      nsCSSAnonBoxPseudoStaticAtom* aPseudoElement,
       const mozilla::AtomArray& aInputWord);
 
 protected:
   typedef uint32_t DFAState;
 
   class Transition final
   {
   public:
--- a/servo/components/style/gecko/regen_atoms.py
+++ b/servo/components/style/gecko/regen_atoms.py
@@ -30,20 +30,21 @@ def map_atom(ident):
 
 
 class Atom:
     def __init__(self, ident, value, hash, ty, atom_type):
         self.ident = "nsGkAtoms_{}".format(ident)
         self.original_ident = ident
         self.value = value
         self.hash = hash
-        # The Gecko type: "nsStaticAtom", "nsICSSPseudoElement", or "nsIAnonBoxPseudo"
+        # The Gecko type: "nsStaticAtom", "nsCSSPseudoElementStaticAtom", or
+        # "nsAnonBoxPseudoStaticAtom".
         self.ty = ty
         # The type of atom: "Atom", "PseudoElement", "NonInheritingAnonBox",
-        # or "InheritingAnonBox"
+        # or "InheritingAnonBox".
         self.atom_type = atom_type
         if self.is_pseudo() or self.is_anon_box():
             self.pseudo_ident = (ident.split("_", 1))[1]
         if self.is_anon_box():
             assert self.is_inheriting_anon_box() or self.is_non_inheriting_anon_box()
 
     def type(self):
         return self.ty
@@ -200,17 +201,17 @@ def write_atom_macro(atoms, file_name):
 
         macro_rules = [RULE_TEMPLATE.format(atom=atom.value, name=atom.ident) for atom in atoms]
         f.write(MACRO_TEMPLATE.format(body=''.join(macro_rules)))
 
 
 def write_pseudo_elements(atoms, target_filename):
     pseudos = []
     for atom in atoms:
-        if atom.type() == "nsICSSPseudoElement" or atom.type() == "nsICSSAnonBoxPseudo":
+        if atom.type() == "nsCSSPseudoElementStaticAtom" or atom.type() == "nsCSSAnonBoxPseudoStaticAtom":
             pseudos.append(atom)
 
     pseudo_definition_template = os.path.join(GECKO_DIR, "pseudo_element_definition.mako.rs")
     print("cargo:rerun-if-changed={}".format(pseudo_definition_template))
     contents = build.render(pseudo_definition_template, PSEUDOS=pseudos)
 
     with FileAvoidWrite(target_filename) as f:
         f.write(contents)
--- a/xpcom/ds/Atom.py
+++ b/xpcom/ds/Atom.py
@@ -9,22 +9,22 @@ class Atom():
         self.string = string
         self.ty = ty
         self.atom_type = self.__class__.__name__
         self.hash = hash_string(string)
 
 
 class PseudoElementAtom(Atom):
     def __init__(self, ident, string):
-        Atom.__init__(self, ident, string, ty="nsICSSPseudoElement")
+        Atom.__init__(self, ident, string, ty="nsCSSPseudoElementStaticAtom")
 
 
 class AnonBoxAtom(Atom):
     def __init__(self, ident, string):
-        Atom.__init__(self, ident, string, ty="nsICSSAnonBoxPseudo")
+        Atom.__init__(self, ident, string, ty="nsCSSAnonBoxPseudoStaticAtom")
 
 
 class NonInheritingAnonBoxAtom(AnonBoxAtom):
     def __init__(self, ident, string):
         AnonBoxAtom.__init__(self, ident, string)
 
 
 class InheritingAnonBoxAtom(AnonBoxAtom):
--- a/xpcom/ds/nsAtom.h
+++ b/xpcom/ds/nsAtom.h
@@ -126,19 +126,19 @@ protected:
 
   ~nsAtom() = default;
 
   const uint32_t mLength:30;
   const uint32_t mKind:2; // nsAtom::AtomKind
   const uint32_t mHash;
 };
 
-// This class would be |final| if it wasn't for nsICSSAnonBoxPseudo and
-// nsICSSPseudoElement, which are trivial subclasses used to ensure only
-// certain static atoms are passed to certain functions.
+// This class would be |final| if it wasn't for nsCSSAnonBoxPseudoStaticAtom
+// and nsCSSPseudoElementStaticAtom, which are trivial subclasses used to
+// ensure only certain static atoms are passed to certain functions.
 class nsStaticAtom : public nsAtom
 {
 public:
   // These are deleted so it's impossible to RefPtr<nsStaticAtom>. Raw
   // nsStaticAtom pointers should be used instead.
   MozExternalRefCountType AddRef() = delete;
   MozExternalRefCountType Release() = delete;
 
--- a/xpcom/ds/nsGkAtoms.h
+++ b/xpcom/ds/nsGkAtoms.h
@@ -41,34 +41,34 @@
 //   public.
 //
 // nsGkAtoms below defines static atoms in a way that satisfies these
 // constraints. It uses nsGkAtomList.h, which defines the names and values of
 // the atoms. nsGkAtomList.h is generated by StaticAtoms.py and has entries
 // that look like this:
 //
 //   GK_ATOM(a, "a", 0x01234567, nsStaticAtom, Atom)
-//   GK_ATOM(bb, "bb", 0x12345678, nsICSSPseudoElement, PseudoElementAtom)
-//   GK_ATOM(ccc, "ccc", 0x23456789, nsICSSAnonBoxPseudo, InheritingAnonBoxAtom)
+//   GK_ATOM(bb, "bb", 0x12345678, nsCSSPseudoElementStaticAtom, PseudoElementAtom)
+//   GK_ATOM(ccc, "ccc", 0x23456789, nsCSSAnonBoxPseudoStaticAtom, InheritingAnonBoxAtom)
 //
 // Comments throughout this file and nsGkAtoms.cpp show how these entries get
 // expanded by macros.
 
 // Trivial subclasses of nsStaticAtom so that function signatures can require
 // an atom from a specific atom list.
 #define DEFINE_STATIC_ATOM_SUBCLASS(name_)                                     \
   class name_ : public nsStaticAtom                                            \
   {                                                                            \
   public:                                                                      \
     constexpr name_(uint32_t aLength, uint32_t aHash, uint32_t aOffset)        \
       : nsStaticAtom(aLength, aHash, aOffset) {}                               \
   };
 
-DEFINE_STATIC_ATOM_SUBCLASS(nsICSSAnonBoxPseudo)
-DEFINE_STATIC_ATOM_SUBCLASS(nsICSSPseudoElement)
+DEFINE_STATIC_ATOM_SUBCLASS(nsCSSAnonBoxPseudoStaticAtom)
+DEFINE_STATIC_ATOM_SUBCLASS(nsCSSPseudoElementStaticAtom)
 
 #undef DEFINE_STATIC_ATOM_SUBCLASS
 
 namespace mozilla {
 namespace detail {
 
 // This `detail` class contains the atom strings and the atom objects. Because
 // they are together in a class, the `mStringOffset` field of the atoms will be