Bug 1400460 - Rename nsIAtom as nsAtom. r=hiro.
authorNicholas Nethercote <nnethercote@mozilla.com>
Tue, 03 Oct 2017 09:05:19 +1100
changeset 435808 67a8e12324569dd730347187e2ffccae486c758b
parent 435807 ab412f11a3cb7074f4cd54192f36ccb609c572d8
child 435809 06d85b20ec65d18ed813f27bec0cb314687dd3b4
child 435828 f961492be7026dd06f0570e839fc6ba5ad92b14f
push id8114
push userjlorenzo@mozilla.com
push dateThu, 02 Nov 2017 16:33:21 +0000
treeherdermozilla-beta@73e0d89a540f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewershiro
bugs1400460, 1400459
milestone58.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 1400460 - Rename nsIAtom as nsAtom. r=hiro. (Path is actually r=froydnj.) Bug 1400459 devirtualized nsIAtom so that it is no longer a subclass of nsISupports. This means that nsAtom is now a better name for it than nsIAtom. MozReview-Commit-ID: 91U22X2NydP
.gdbinit
.lldbinit
accessible/base/ARIAMap.cpp
accessible/base/ARIAMap.h
accessible/base/ARIAStateMap.cpp
accessible/base/AccEvent.h
accessible/base/AccIterator.cpp
accessible/base/AccIterator.h
accessible/base/Logging.cpp
accessible/base/nsAccUtils.cpp
accessible/base/nsAccUtils.h
accessible/base/nsAccessibilityService.cpp
accessible/base/nsAccessibilityService.h
accessible/base/nsCoreUtils.cpp
accessible/base/nsCoreUtils.h
accessible/base/nsTextEquivUtils.cpp
accessible/base/nsTextEquivUtils.h
accessible/generic/Accessible-inl.h
accessible/generic/Accessible.cpp
accessible/generic/Accessible.h
accessible/generic/DocAccessible.cpp
accessible/generic/DocAccessible.h
accessible/generic/HyperTextAccessible.cpp
accessible/generic/HyperTextAccessible.h
accessible/html/HTMLElementAccessibles.cpp
accessible/html/HTMLElementAccessibles.h
accessible/ipc/ProxyAccessibleShared.h
accessible/ipc/other/DocAccessibleChild.cpp
accessible/ipc/other/ProxyAccessible.cpp
accessible/mac/mozAccessible.mm
accessible/windows/msaa/GeckoCustom.cpp
accessible/xul/XULSliderAccessible.cpp
accessible/xul/XULSliderAccessible.h
caps/BasePrincipal.cpp
caps/BasePrincipal.h
caps/ExpandedPrincipal.cpp
caps/ExpandedPrincipal.h
docshell/base/nsDocShell.cpp
docshell/base/nsDocShellTreeOwner.cpp
docshell/shistory/nsSHEntryShared.cpp
dom/animation/AnimationUtils.cpp
dom/animation/CSSPseudoElement.cpp
dom/animation/CSSPseudoElement.h
dom/animation/EffectCompositor.cpp
dom/animation/EffectCompositor.h
dom/animation/EffectSet.cpp
dom/animation/EffectSet.h
dom/animation/KeyframeEffectReadOnly.cpp
dom/asmjscache/AsmJSCache.cpp
dom/base/AnonymousContent.cpp
dom/base/Attr.cpp
dom/base/CustomElementRegistry.cpp
dom/base/CustomElementRegistry.h
dom/base/DOMImplementation.cpp
dom/base/DirectionalityUtils.cpp
dom/base/DocumentFragment.h
dom/base/DocumentType.cpp
dom/base/DocumentType.h
dom/base/Element.cpp
dom/base/Element.h
dom/base/FragmentOrElement.cpp
dom/base/FragmentOrElement.h
dom/base/IDTracker.cpp
dom/base/IDTracker.h
dom/base/Link.cpp
dom/base/Link.h
dom/base/NodeInfo.cpp
dom/base/NodeInfo.h
dom/base/NodeInfoInlines.h
dom/base/ShadowRoot.cpp
dom/base/ShadowRoot.h
dom/base/WebSocket.cpp
dom/base/WebSocket.h
dom/base/nsAtomListUtils.cpp
dom/base/nsAtomListUtils.h
dom/base/nsAttrAndChildArray.cpp
dom/base/nsAttrAndChildArray.h
dom/base/nsAttrName.h
dom/base/nsAttrValue.cpp
dom/base/nsAttrValue.h
dom/base/nsAttrValueInlines.h
dom/base/nsCCUncollectableMarker.cpp
dom/base/nsContentIterator.cpp
dom/base/nsContentList.cpp
dom/base/nsContentList.h
dom/base/nsContentListDeclarations.h
dom/base/nsContentSink.cpp
dom/base/nsContentSink.h
dom/base/nsContentUtils.cpp
dom/base/nsContentUtils.h
dom/base/nsDOMAttributeMap.cpp
dom/base/nsDOMAttributeMap.h
dom/base/nsDOMDataChannel.cpp
dom/base/nsDOMDataChannel.h
dom/base/nsDOMMutationObserver.cpp
dom/base/nsDOMMutationObserver.h
dom/base/nsDOMTokenList.cpp
dom/base/nsDOMTokenList.h
dom/base/nsDOMWindowUtils.cpp
dom/base/nsDocument.cpp
dom/base/nsDocument.h
dom/base/nsFrameLoader.cpp
dom/base/nsFrameLoader.h
dom/base/nsFrameMessageManager.h
dom/base/nsGenericDOMDataNode.cpp
dom/base/nsGenericDOMDataNode.h
dom/base/nsGkAtoms.cpp
dom/base/nsGkAtoms.h
dom/base/nsGlobalWindow.cpp
dom/base/nsGlobalWindow.h
dom/base/nsHTMLContentSerializer.cpp
dom/base/nsHTMLContentSerializer.h
dom/base/nsIContent.h
dom/base/nsIContentInlines.h
dom/base/nsIDocument.h
dom/base/nsIMutationObserver.h
dom/base/nsINode.cpp
dom/base/nsINode.h
dom/base/nsIdentifierMapEntry.h
dom/base/nsJSEnvironment.cpp
dom/base/nsLineBreaker.cpp
dom/base/nsLineBreaker.h
dom/base/nsMappedAttributeElement.cpp
dom/base/nsMappedAttributeElement.h
dom/base/nsMappedAttributes.cpp
dom/base/nsMappedAttributes.h
dom/base/nsNameSpaceManager.cpp
dom/base/nsNameSpaceManager.h
dom/base/nsNodeInfoManager.cpp
dom/base/nsNodeInfoManager.h
dom/base/nsNodeUtils.cpp
dom/base/nsNodeUtils.h
dom/base/nsObjectLoadingContent.cpp
dom/base/nsPlainTextSerializer.cpp
dom/base/nsPlainTextSerializer.h
dom/base/nsPropertyTable.cpp
dom/base/nsPropertyTable.h
dom/base/nsStyledElement.cpp
dom/base/nsStyledElement.h
dom/base/nsTextNode.cpp
dom/base/nsTreeSanitizer.cpp
dom/base/nsTreeSanitizer.h
dom/base/nsXHTMLContentSerializer.cpp
dom/base/nsXHTMLContentSerializer.h
dom/base/nsXMLContentSerializer.cpp
dom/base/nsXMLContentSerializer.h
dom/base/nsXMLNameSpaceMap.cpp
dom/base/nsXMLNameSpaceMap.h
dom/bindings/DOMString.h
dom/canvas/CanvasRenderingContext2D.cpp
dom/canvas/CanvasRenderingContext2D.h
dom/events/CommandEvent.cpp
dom/events/ContentEventHandler.cpp
dom/events/DOMEventTargetHelper.cpp
dom/events/DOMEventTargetHelper.h
dom/events/DataTransfer.cpp
dom/events/EventListenerManager.cpp
dom/events/EventListenerManager.h
dom/events/EventListenerService.cpp
dom/events/EventListenerService.h
dom/events/EventStateManager.cpp
dom/events/EventTarget.cpp
dom/events/EventTarget.h
dom/events/IMEContentObserver.cpp
dom/events/InternalMutationEvent.h
dom/events/JSEventHandler.cpp
dom/events/JSEventHandler.h
dom/html/HTMLAllCollection.cpp
dom/html/HTMLAnchorElement.cpp
dom/html/HTMLAnchorElement.h
dom/html/HTMLAreaElement.cpp
dom/html/HTMLAreaElement.h
dom/html/HTMLBRElement.cpp
dom/html/HTMLBRElement.h
dom/html/HTMLBodyElement.cpp
dom/html/HTMLBodyElement.h
dom/html/HTMLButtonElement.cpp
dom/html/HTMLButtonElement.h
dom/html/HTMLCanvasElement.cpp
dom/html/HTMLCanvasElement.h
dom/html/HTMLContentElement.cpp
dom/html/HTMLContentElement.h
dom/html/HTMLDataListElement.cpp
dom/html/HTMLDataListElement.h
dom/html/HTMLDetailsElement.cpp
dom/html/HTMLDetailsElement.h
dom/html/HTMLDivElement.cpp
dom/html/HTMLDivElement.h
dom/html/HTMLEmbedElement.cpp
dom/html/HTMLEmbedElement.h
dom/html/HTMLFieldSetElement.cpp
dom/html/HTMLFieldSetElement.h
dom/html/HTMLFontElement.cpp
dom/html/HTMLFontElement.h
dom/html/HTMLFormElement.cpp
dom/html/HTMLFormElement.h
dom/html/HTMLFormSubmission.cpp
dom/html/HTMLFrameElement.cpp
dom/html/HTMLFrameElement.h
dom/html/HTMLFrameSetElement.cpp
dom/html/HTMLFrameSetElement.h
dom/html/HTMLHRElement.cpp
dom/html/HTMLHRElement.h
dom/html/HTMLHeadingElement.cpp
dom/html/HTMLHeadingElement.h
dom/html/HTMLIFrameElement.cpp
dom/html/HTMLIFrameElement.h
dom/html/HTMLImageElement.cpp
dom/html/HTMLImageElement.h
dom/html/HTMLInputElement.cpp
dom/html/HTMLInputElement.h
dom/html/HTMLLIElement.cpp
dom/html/HTMLLIElement.h
dom/html/HTMLLegendElement.cpp
dom/html/HTMLLegendElement.h
dom/html/HTMLLinkElement.cpp
dom/html/HTMLLinkElement.h
dom/html/HTMLMediaElement.cpp
dom/html/HTMLMediaElement.h
dom/html/HTMLMenuElement.cpp
dom/html/HTMLMenuElement.h
dom/html/HTMLMenuItemElement.cpp
dom/html/HTMLMenuItemElement.h
dom/html/HTMLMetaElement.cpp
dom/html/HTMLMetaElement.h
dom/html/HTMLMeterElement.cpp
dom/html/HTMLMeterElement.h
dom/html/HTMLObjectElement.cpp
dom/html/HTMLObjectElement.h
dom/html/HTMLOptGroupElement.cpp
dom/html/HTMLOptGroupElement.h
dom/html/HTMLOptionElement.cpp
dom/html/HTMLOptionElement.h
dom/html/HTMLOptionsCollection.cpp
dom/html/HTMLOutputElement.cpp
dom/html/HTMLOutputElement.h
dom/html/HTMLParagraphElement.cpp
dom/html/HTMLParagraphElement.h
dom/html/HTMLPreElement.cpp
dom/html/HTMLPreElement.h
dom/html/HTMLProgressElement.cpp
dom/html/HTMLProgressElement.h
dom/html/HTMLScriptElement.cpp
dom/html/HTMLScriptElement.h
dom/html/HTMLSelectElement.cpp
dom/html/HTMLSelectElement.h
dom/html/HTMLSharedElement.cpp
dom/html/HTMLSharedElement.h
dom/html/HTMLSharedListElement.cpp
dom/html/HTMLSharedListElement.h
dom/html/HTMLSourceElement.cpp
dom/html/HTMLSourceElement.h
dom/html/HTMLSpanElement.cpp
dom/html/HTMLSpanElement.h
dom/html/HTMLStyleElement.cpp
dom/html/HTMLStyleElement.h
dom/html/HTMLTableCaptionElement.cpp
dom/html/HTMLTableCaptionElement.h
dom/html/HTMLTableCellElement.cpp
dom/html/HTMLTableCellElement.h
dom/html/HTMLTableColElement.cpp
dom/html/HTMLTableColElement.h
dom/html/HTMLTableElement.cpp
dom/html/HTMLTableElement.h
dom/html/HTMLTableRowElement.cpp
dom/html/HTMLTableRowElement.h
dom/html/HTMLTableSectionElement.cpp
dom/html/HTMLTableSectionElement.h
dom/html/HTMLTemplateElement.cpp
dom/html/HTMLTextAreaElement.cpp
dom/html/HTMLTextAreaElement.h
dom/html/HTMLTrackElement.cpp
dom/html/HTMLTrackElement.h
dom/html/HTMLVideoElement.cpp
dom/html/HTMLVideoElement.h
dom/html/nsDOMStringMap.cpp
dom/html/nsGenericHTMLElement.cpp
dom/html/nsGenericHTMLElement.h
dom/html/nsGenericHTMLFrameElement.cpp
dom/html/nsGenericHTMLFrameElement.h
dom/html/nsHTMLContentSink.cpp
dom/html/nsHTMLDocument.cpp
dom/html/nsHTMLDocument.h
dom/mathml/nsMathMLElement.cpp
dom/mathml/nsMathMLElement.h
dom/media/doctor/DecoderDoctorDiagnostics.cpp
dom/media/webaudio/ScriptProcessorNode.cpp
dom/media/webaudio/ScriptProcessorNode.h
dom/script/ScriptElement.cpp
dom/smil/nsSMILAnimationController.cpp
dom/smil/nsSMILAnimationFunction.cpp
dom/smil/nsSMILAnimationFunction.h
dom/smil/nsSMILCSSProperty.h
dom/smil/nsSMILParserUtils.cpp
dom/smil/nsSMILSetAnimationFunction.cpp
dom/smil/nsSMILSetAnimationFunction.h
dom/smil/nsSMILTargetIdentifier.h
dom/smil/nsSMILTimeValueSpecParams.h
dom/smil/nsSMILTimedElement.cpp
dom/smil/nsSMILTimedElement.h
dom/svg/SVGAElement.cpp
dom/svg/SVGAElement.h
dom/svg/SVGAnimateMotionElement.cpp
dom/svg/SVGAnimateMotionElement.h
dom/svg/SVGAnimateTransformElement.cpp
dom/svg/SVGAnimateTransformElement.h
dom/svg/SVGAnimationElement.cpp
dom/svg/SVGAnimationElement.h
dom/svg/SVGComponentTransferFunctionElement.h
dom/svg/SVGDefsElement.cpp
dom/svg/SVGDefsElement.h
dom/svg/SVGElementFactory.cpp
dom/svg/SVGElementFactory.h
dom/svg/SVGFEBlendElement.cpp
dom/svg/SVGFEBlendElement.h
dom/svg/SVGFEColorMatrixElement.cpp
dom/svg/SVGFEColorMatrixElement.h
dom/svg/SVGFEComponentTransferElement.cpp
dom/svg/SVGFEComponentTransferElement.h
dom/svg/SVGFECompositeElement.cpp
dom/svg/SVGFECompositeElement.h
dom/svg/SVGFEConvolveMatrixElement.cpp
dom/svg/SVGFEConvolveMatrixElement.h
dom/svg/SVGFEDiffuseLightingElement.cpp
dom/svg/SVGFEDiffuseLightingElement.h
dom/svg/SVGFEDisplacementMapElement.cpp
dom/svg/SVGFEDisplacementMapElement.h
dom/svg/SVGFEDistantLightElement.cpp
dom/svg/SVGFEDistantLightElement.h
dom/svg/SVGFEDropShadowElement.cpp
dom/svg/SVGFEDropShadowElement.h
dom/svg/SVGFEFloodElement.cpp
dom/svg/SVGFEFloodElement.h
dom/svg/SVGFEGaussianBlurElement.cpp
dom/svg/SVGFEGaussianBlurElement.h
dom/svg/SVGFEImageElement.cpp
dom/svg/SVGFEImageElement.h
dom/svg/SVGFEMergeNodeElement.cpp
dom/svg/SVGFEMergeNodeElement.h
dom/svg/SVGFEMorphologyElement.cpp
dom/svg/SVGFEMorphologyElement.h
dom/svg/SVGFEOffsetElement.cpp
dom/svg/SVGFEOffsetElement.h
dom/svg/SVGFEPointLightElement.cpp
dom/svg/SVGFEPointLightElement.h
dom/svg/SVGFESpecularLightingElement.cpp
dom/svg/SVGFESpecularLightingElement.h
dom/svg/SVGFESpotLightElement.cpp
dom/svg/SVGFESpotLightElement.h
dom/svg/SVGFETileElement.cpp
dom/svg/SVGFETileElement.h
dom/svg/SVGFETurbulenceElement.cpp
dom/svg/SVGFETurbulenceElement.h
dom/svg/SVGFilterElement.cpp
dom/svg/SVGFilterElement.h
dom/svg/SVGForeignObjectElement.cpp
dom/svg/SVGForeignObjectElement.h
dom/svg/SVGFragmentIdentifier.cpp
dom/svg/SVGGElement.cpp
dom/svg/SVGGElement.h
dom/svg/SVGGeometryElement.cpp
dom/svg/SVGGeometryElement.h
dom/svg/SVGGradientElement.cpp
dom/svg/SVGGradientElement.h
dom/svg/SVGImageElement.cpp
dom/svg/SVGImageElement.h
dom/svg/SVGLength.cpp
dom/svg/SVGLineElement.cpp
dom/svg/SVGLineElement.h
dom/svg/SVGMPathElement.cpp
dom/svg/SVGMPathElement.h
dom/svg/SVGMarkerElement.cpp
dom/svg/SVGMarkerElement.h
dom/svg/SVGMaskElement.cpp
dom/svg/SVGMaskElement.h
dom/svg/SVGMotionSMILAnimationFunction.cpp
dom/svg/SVGMotionSMILAnimationFunction.h
dom/svg/SVGPathElement.cpp
dom/svg/SVGPathElement.h
dom/svg/SVGPatternElement.cpp
dom/svg/SVGPatternElement.h
dom/svg/SVGPolyElement.cpp
dom/svg/SVGPolyElement.h
dom/svg/SVGSVGElement.cpp
dom/svg/SVGSVGElement.h
dom/svg/SVGScriptElement.cpp
dom/svg/SVGScriptElement.h
dom/svg/SVGStopElement.cpp
dom/svg/SVGStopElement.h
dom/svg/SVGStyleElement.cpp
dom/svg/SVGStyleElement.h
dom/svg/SVGSwitchElement.cpp
dom/svg/SVGSwitchElement.h
dom/svg/SVGTSpanElement.cpp
dom/svg/SVGTSpanElement.h
dom/svg/SVGTests.cpp
dom/svg/SVGTests.h
dom/svg/SVGTextElement.cpp
dom/svg/SVGTextElement.h
dom/svg/SVGTextPathElement.cpp
dom/svg/SVGTextPathElement.h
dom/svg/SVGTransformListParser.cpp
dom/svg/SVGTransformableElement.cpp
dom/svg/SVGTransformableElement.h
dom/svg/SVGUseElement.cpp
dom/svg/SVGUseElement.h
dom/svg/SVGViewportElement.cpp
dom/svg/SVGViewportElement.h
dom/svg/nsSVGAngle.cpp
dom/svg/nsSVGAnimatedTransformList.cpp
dom/svg/nsSVGAnimatedTransformList.h
dom/svg/nsSVGBoolean.cpp
dom/svg/nsSVGBoolean.h
dom/svg/nsSVGElement.cpp
dom/svg/nsSVGElement.h
dom/svg/nsSVGEnum.cpp
dom/svg/nsSVGEnum.h
dom/svg/nsSVGFilters.cpp
dom/svg/nsSVGFilters.h
dom/svg/nsSVGLength2.cpp
dom/xbl/XBLChildrenElement.cpp
dom/xbl/XBLChildrenElement.h
dom/xbl/nsBindingManager.cpp
dom/xbl/nsBindingManager.h
dom/xbl/nsXBLBinding.cpp
dom/xbl/nsXBLBinding.h
dom/xbl/nsXBLContentSink.cpp
dom/xbl/nsXBLContentSink.h
dom/xbl/nsXBLEventHandler.cpp
dom/xbl/nsXBLEventHandler.h
dom/xbl/nsXBLProtoImplField.cpp
dom/xbl/nsXBLProtoImplField.h
dom/xbl/nsXBLProtoImplMember.h
dom/xbl/nsXBLProtoImplMethod.cpp
dom/xbl/nsXBLProtoImplMethod.h
dom/xbl/nsXBLProtoImplProperty.cpp
dom/xbl/nsXBLProtoImplProperty.h
dom/xbl/nsXBLPrototypeBinding.cpp
dom/xbl/nsXBLPrototypeBinding.h
dom/xbl/nsXBLPrototypeHandler.cpp
dom/xbl/nsXBLPrototypeHandler.h
dom/xbl/nsXBLPrototypeResources.cpp
dom/xbl/nsXBLPrototypeResources.h
dom/xbl/nsXBLResourceLoader.cpp
dom/xbl/nsXBLResourceLoader.h
dom/xbl/nsXBLWindowKeyHandler.cpp
dom/xbl/nsXBLWindowKeyHandler.h
dom/xml/ProcessingInstruction.cpp
dom/xml/ProcessingInstruction.h
dom/xml/nsXMLContentSink.cpp
dom/xml/nsXMLContentSink.h
dom/xml/nsXMLElement.cpp
dom/xml/nsXMLFragmentContentSink.cpp
dom/xml/nsXMLPrettyPrinter.cpp
dom/xslt/base/txExpandedName.cpp
dom/xslt/base/txExpandedName.h
dom/xslt/base/txExpandedNameMap.h
dom/xslt/base/txNamespaceMap.cpp
dom/xslt/base/txNamespaceMap.h
dom/xslt/base/txStringUtils.h
dom/xslt/xml/txXMLUtils.cpp
dom/xslt/xml/txXMLUtils.h
dom/xslt/xpath/XPathEvaluator.cpp
dom/xslt/xpath/XPathExpression.cpp
dom/xslt/xpath/XPathResult.cpp
dom/xslt/xpath/txCoreFunctionCall.cpp
dom/xslt/xpath/txExpr.h
dom/xslt/xpath/txExprParser.cpp
dom/xslt/xpath/txExprParser.h
dom/xslt/xpath/txForwardContext.cpp
dom/xslt/xpath/txFunctionCall.cpp
dom/xslt/xpath/txIXPathContext.h
dom/xslt/xpath/txMozillaXPathTreeWalker.cpp
dom/xslt/xpath/txNameTest.cpp
dom/xslt/xpath/txNamedAttributeStep.cpp
dom/xslt/xpath/txNodeSetContext.cpp
dom/xslt/xpath/txNodeTypeTest.cpp
dom/xslt/xpath/txSingleNodeContext.h
dom/xslt/xpath/txVariableRefExpr.cpp
dom/xslt/xpath/txXPCOMExtensionFunction.cpp
dom/xslt/xpath/txXPathOptimizer.cpp
dom/xslt/xpath/txXPathTreeWalker.h
dom/xslt/xslt/txBufferingHandler.cpp
dom/xslt/xslt/txCurrentFunctionCall.cpp
dom/xslt/xslt/txDocumentFunctionCall.cpp
dom/xslt/xslt/txEXSLTFunctions.cpp
dom/xslt/xslt/txExecutionState.cpp
dom/xslt/xslt/txExecutionState.h
dom/xslt/xslt/txFormatNumberFunctionCall.cpp
dom/xslt/xslt/txGenerateIdFunctionCall.cpp
dom/xslt/xslt/txInstructions.cpp
dom/xslt/xslt/txInstructions.h
dom/xslt/xslt/txKeyFunctionCall.cpp
dom/xslt/xslt/txMozillaTextOutput.cpp
dom/xslt/xslt/txMozillaTextOutput.h
dom/xslt/xslt/txMozillaXMLOutput.cpp
dom/xslt/xslt/txMozillaXMLOutput.h
dom/xslt/xslt/txMozillaXSLTProcessor.cpp
dom/xslt/xslt/txPatternParser.cpp
dom/xslt/xslt/txStylesheet.h
dom/xslt/xslt/txStylesheetCompileHandlers.cpp
dom/xslt/xslt/txStylesheetCompileHandlers.h
dom/xslt/xslt/txStylesheetCompiler.cpp
dom/xslt/xslt/txStylesheetCompiler.h
dom/xslt/xslt/txTextHandler.cpp
dom/xslt/xslt/txUnknownHandler.cpp
dom/xslt/xslt/txXMLEventHandler.h
dom/xslt/xslt/txXSLTEnvironmentFunctionCall.cpp
dom/xslt/xslt/txXSLTNumber.cpp
dom/xslt/xslt/txXSLTPatterns.cpp
dom/xslt/xslt/txXSLTPatterns.h
dom/xul/XULDocument.cpp
dom/xul/XULDocument.h
dom/xul/nsXULContentSink.cpp
dom/xul/nsXULElement.cpp
dom/xul/nsXULElement.h
dom/xul/nsXULPopupListener.cpp
dom/xul/nsXULPrototypeDocument.cpp
dom/xul/nsXULPrototypeDocument.h
dom/xul/templates/nsContentTestNode.cpp
dom/xul/templates/nsContentTestNode.h
dom/xul/templates/nsIXULTemplateBuilder.idl
dom/xul/templates/nsIXULTemplateQueryProcessor.idl
dom/xul/templates/nsIXULTemplateResult.idl
dom/xul/templates/nsRDFBinding.cpp
dom/xul/templates/nsRDFBinding.h
dom/xul/templates/nsRDFConInstanceTestNode.cpp
dom/xul/templates/nsRDFConInstanceTestNode.h
dom/xul/templates/nsRDFConMemberTestNode.cpp
dom/xul/templates/nsRDFConMemberTestNode.h
dom/xul/templates/nsRDFPropertyTestNode.cpp
dom/xul/templates/nsRDFPropertyTestNode.h
dom/xul/templates/nsRDFQuery.h
dom/xul/templates/nsRuleNetwork.cpp
dom/xul/templates/nsRuleNetwork.h
dom/xul/templates/nsTemplateRule.cpp
dom/xul/templates/nsTemplateRule.h
dom/xul/templates/nsXMLBinding.cpp
dom/xul/templates/nsXMLBinding.h
dom/xul/templates/nsXULContentBuilder.cpp
dom/xul/templates/nsXULContentUtils.cpp
dom/xul/templates/nsXULContentUtils.h
dom/xul/templates/nsXULSortService.cpp
dom/xul/templates/nsXULSortService.h
dom/xul/templates/nsXULTemplateBuilder.cpp
dom/xul/templates/nsXULTemplateBuilder.h
dom/xul/templates/nsXULTemplateQueryProcessorRDF.cpp
dom/xul/templates/nsXULTemplateQueryProcessorRDF.h
dom/xul/templates/nsXULTemplateQueryProcessorStorage.cpp
dom/xul/templates/nsXULTemplateQueryProcessorStorage.h
dom/xul/templates/nsXULTemplateQueryProcessorXML.cpp
dom/xul/templates/nsXULTemplateQueryProcessorXML.h
dom/xul/templates/nsXULTemplateResultRDF.cpp
dom/xul/templates/nsXULTemplateResultRDF.h
dom/xul/templates/nsXULTemplateResultStorage.cpp
dom/xul/templates/nsXULTemplateResultXML.cpp
dom/xul/templates/nsXULTreeBuilder.cpp
dom/xul/templates/nsXULTreeBuilder.h
editor/composer/nsComposerCommands.cpp
editor/composer/nsComposerCommands.h
editor/libeditor/CSSEditUtils.cpp
editor/libeditor/CSSEditUtils.h
editor/libeditor/ChangeAttributeTransaction.cpp
editor/libeditor/ChangeAttributeTransaction.h
editor/libeditor/ChangeStyleTransaction.cpp
editor/libeditor/ChangeStyleTransaction.h
editor/libeditor/CreateElementTransaction.cpp
editor/libeditor/CreateElementTransaction.h
editor/libeditor/EditAggregateTransaction.cpp
editor/libeditor/EditAggregateTransaction.h
editor/libeditor/EditorBase.cpp
editor/libeditor/EditorBase.h
editor/libeditor/EditorUtils.h
editor/libeditor/HTMLAnonymousNodeEditor.cpp
editor/libeditor/HTMLEditRules.cpp
editor/libeditor/HTMLEditRules.h
editor/libeditor/HTMLEditUtils.cpp
editor/libeditor/HTMLEditor.cpp
editor/libeditor/HTMLEditor.h
editor/libeditor/HTMLEditorDataTransfer.cpp
editor/libeditor/HTMLEditorObjectResizer.cpp
editor/libeditor/HTMLStyleEditor.cpp
editor/libeditor/HTMLTableEditor.cpp
editor/libeditor/HTMLURIRefObject.cpp
editor/libeditor/PlaceholderTransaction.cpp
editor/libeditor/PlaceholderTransaction.h
editor/libeditor/TextEditor.cpp
editor/libeditor/TextEditor.h
editor/libeditor/TypeInState.cpp
editor/libeditor/TypeInState.h
editor/libeditor/nsIAbsorbingTransaction.h
editor/txtsvc/nsFilteredContentIterator.cpp
editor/txtsvc/nsFilteredContentIterator.h
editor/txtsvc/nsTSAtomList.h
editor/txtsvc/nsTextServicesDocument.cpp
editor/txtsvc/nsTextServicesDocument.h
extensions/spellcheck/src/mozInlineSpellWordUtil.cpp
gfx/src/nsDeviceContext.cpp
gfx/src/nsDeviceContext.h
gfx/src/nsFontMetrics.cpp
gfx/src/nsFontMetrics.h
gfx/src/nsITheme.h
gfx/src/nsThebesFontEnumerator.cpp
gfx/thebes/gfxDWriteFontList.h
gfx/thebes/gfxFcPlatformFontList.cpp
gfx/thebes/gfxFcPlatformFontList.h
gfx/thebes/gfxFont.cpp
gfx/thebes/gfxFont.h
gfx/thebes/gfxFontEntry.h
gfx/thebes/gfxGDIFontList.h
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxPlatform.h
gfx/thebes/gfxPlatformFontList.cpp
gfx/thebes/gfxPlatformFontList.h
gfx/thebes/gfxPlatformGtk.cpp
gfx/thebes/gfxPlatformGtk.h
gfx/thebes/gfxTextRun.h
intl/hyphenation/glue/nsHyphenationManager.cpp
intl/hyphenation/glue/nsHyphenationManager.h
intl/locale/nsLanguageAtomService.cpp
intl/locale/nsLanguageAtomService.h
js/src/devtools/rootAnalysis/analyzeHeapWrites.js
js/src/devtools/rootAnalysis/annotations.js
layout/base/GeckoRestyleManager.cpp
layout/base/GeckoRestyleManager.h
layout/base/PositionedEventTargeting.cpp
layout/base/PresShell.cpp
layout/base/RestyleManager.cpp
layout/base/RestyleManager.h
layout/base/RestyleManagerInlines.h
layout/base/ServoRestyleManager.cpp
layout/base/ServoRestyleManager.h
layout/base/StaticPresData.cpp
layout/base/StaticPresData.h
layout/base/nsCSSFrameConstructor.cpp
layout/base/nsCSSFrameConstructor.h
layout/base/nsGenConList.cpp
layout/base/nsLayoutUtils.cpp
layout/base/nsLayoutUtils.h
layout/base/nsPresContext.cpp
layout/base/nsPresContext.h
layout/forms/nsCheckboxRadioFrame.cpp
layout/forms/nsCheckboxRadioFrame.h
layout/forms/nsColorControlFrame.cpp
layout/forms/nsColorControlFrame.h
layout/forms/nsComboboxControlFrame.cpp
layout/forms/nsComboboxControlFrame.h
layout/forms/nsDateTimeControlFrame.cpp
layout/forms/nsDateTimeControlFrame.h
layout/forms/nsFileControlFrame.cpp
layout/forms/nsFileControlFrame.h
layout/forms/nsGfxButtonControlFrame.cpp
layout/forms/nsGfxButtonControlFrame.h
layout/forms/nsHTMLButtonControlFrame.cpp
layout/forms/nsHTMLButtonControlFrame.h
layout/forms/nsIFormControlFrame.h
layout/forms/nsImageControlFrame.cpp
layout/forms/nsListControlFrame.cpp
layout/forms/nsListControlFrame.h
layout/forms/nsMeterFrame.cpp
layout/forms/nsMeterFrame.h
layout/forms/nsNumberControlFrame.cpp
layout/forms/nsNumberControlFrame.h
layout/forms/nsProgressFrame.cpp
layout/forms/nsProgressFrame.h
layout/forms/nsRangeFrame.cpp
layout/forms/nsRangeFrame.h
layout/forms/nsTextControlFrame.cpp
layout/forms/nsTextControlFrame.h
layout/generic/RubyUtils.h
layout/generic/ScrollbarActivity.cpp
layout/generic/TextOverflow.cpp
layout/generic/ViewportFrame.cpp
layout/generic/nsBlockFrame.cpp
layout/generic/nsBlockFrame.h
layout/generic/nsContainerFrame.cpp
layout/generic/nsContainerFrame.h
layout/generic/nsFrame.cpp
layout/generic/nsFrame.h
layout/generic/nsFrameSelection.cpp
layout/generic/nsFrameSetFrame.h
layout/generic/nsGfxScrollFrame.cpp
layout/generic/nsGfxScrollFrame.h
layout/generic/nsHTMLParts.h
layout/generic/nsIFrame.h
layout/generic/nsIScrollableFrame.h
layout/generic/nsImageFrame.cpp
layout/generic/nsImageFrame.h
layout/generic/nsImageMap.cpp
layout/generic/nsInlineFrame.cpp
layout/generic/nsInlineFrame.h
layout/generic/nsRubyContentFrame.cpp
layout/generic/nsSubDocumentFrame.cpp
layout/generic/nsSubDocumentFrame.h
layout/generic/nsTextFrame.cpp
layout/generic/nsTextRunTransformations.cpp
layout/generic/nsTextRunTransformations.h
layout/generic/nsVideoFrame.cpp
layout/generic/nsVideoFrame.h
layout/inspector/inDOMUtils.cpp
layout/inspector/inDOMUtils.h
layout/inspector/inDOMView.cpp
layout/mathml/nsMathMLContainerFrame.cpp
layout/mathml/nsMathMLContainerFrame.h
layout/mathml/nsMathMLmactionFrame.cpp
layout/mathml/nsMathMLmactionFrame.h
layout/mathml/nsMathMLmencloseFrame.cpp
layout/mathml/nsMathMLmencloseFrame.h
layout/mathml/nsMathMLmfencedFrame.cpp
layout/mathml/nsMathMLmfencedFrame.h
layout/mathml/nsMathMLmfracFrame.cpp
layout/mathml/nsMathMLmfracFrame.h
layout/mathml/nsMathMLmmultiscriptsFrame.cpp
layout/mathml/nsMathMLmoFrame.cpp
layout/mathml/nsMathMLmoFrame.h
layout/mathml/nsMathMLmrowFrame.cpp
layout/mathml/nsMathMLmrowFrame.h
layout/mathml/nsMathMLmsqrtFrame.cpp
layout/mathml/nsMathMLmsqrtFrame.h
layout/mathml/nsMathMLmtableFrame.cpp
layout/mathml/nsMathMLmtableFrame.h
layout/mathml/nsMathMLmunderoverFrame.cpp
layout/mathml/nsMathMLmunderoverFrame.h
layout/style/AnimationCollection.cpp
layout/style/AnimationCollection.h
layout/style/CSSNamespaceRule.h
layout/style/CSSStyleSheet.cpp
layout/style/CounterStyleManager.cpp
layout/style/CounterStyleManager.h
layout/style/GeckoStyleContext.cpp
layout/style/GeckoStyleContext.h
layout/style/GenericSpecifiedValues.h
layout/style/GenericSpecifiedValuesInlines.h
layout/style/NameSpaceRule.h
layout/style/ServoBindingList.h
layout/style/ServoBindings.cpp
layout/style/ServoBindings.h
layout/style/ServoBindings.toml
layout/style/ServoElementSnapshot.cpp
layout/style/ServoElementSnapshot.h
layout/style/ServoKeyframesRule.cpp
layout/style/ServoNamespaceRule.cpp
layout/style/ServoNamespaceRule.h
layout/style/ServoSpecifiedValues.cpp
layout/style/ServoSpecifiedValues.h
layout/style/ServoStyleContext.cpp
layout/style/ServoStyleContext.h
layout/style/ServoStyleRule.cpp
layout/style/ServoStyleSet.cpp
layout/style/ServoStyleSet.h
layout/style/StyleRule.cpp
layout/style/StyleRule.h
layout/style/StyleSetHandle.h
layout/style/StyleSetHandleInlines.h
layout/style/nsAnimationManager.h
layout/style/nsCSSAnonBoxList.h
layout/style/nsCSSAnonBoxes.cpp
layout/style/nsCSSAnonBoxes.h
layout/style/nsCSSCounterStyleRule.h
layout/style/nsCSSParser.cpp
layout/style/nsCSSParser.h
layout/style/nsCSSPseudoClassList.h
layout/style/nsCSSPseudoClasses.cpp
layout/style/nsCSSPseudoClasses.h
layout/style/nsCSSPseudoElementList.h
layout/style/nsCSSPseudoElements.cpp
layout/style/nsCSSPseudoElements.h
layout/style/nsCSSRuleProcessor.cpp
layout/style/nsCSSRuleProcessor.h
layout/style/nsCSSRules.cpp
layout/style/nsCSSValue.cpp
layout/style/nsCSSValue.h
layout/style/nsComputedDOMStyle.cpp
layout/style/nsComputedDOMStyle.h
layout/style/nsHTMLStyleSheet.cpp
layout/style/nsHTMLStyleSheet.h
layout/style/nsMediaFeatures.cpp
layout/style/nsMediaFeatures.h
layout/style/nsMediaList.h
layout/style/nsRuleData.h
layout/style/nsRuleNode.cpp
layout/style/nsRuleProcessorData.h
layout/style/nsStyleContext.cpp
layout/style/nsStyleContext.h
layout/style/nsStyleSet.cpp
layout/style/nsStyleSet.h
layout/style/nsStyleStruct.cpp
layout/style/nsStyleStruct.h
layout/style/nsStyleUtil.h
layout/style/nsTransitionManager.h
layout/svg/SVGFEContainerFrame.cpp
layout/svg/SVGFEImageFrame.cpp
layout/svg/SVGFELeafFrame.cpp
layout/svg/SVGFEUnstyledLeafFrame.cpp
layout/svg/SVGGeometryFrame.cpp
layout/svg/SVGGeometryFrame.h
layout/svg/SVGObserverUtils.cpp
layout/svg/SVGObserverUtils.h
layout/svg/SVGTextFrame.cpp
layout/svg/SVGTextFrame.h
layout/svg/SVGViewFrame.cpp
layout/svg/nsSVGAFrame.cpp
layout/svg/nsSVGClipPathFrame.cpp
layout/svg/nsSVGClipPathFrame.h
layout/svg/nsSVGFilterFrame.cpp
layout/svg/nsSVGFilterFrame.h
layout/svg/nsSVGForeignObjectFrame.cpp
layout/svg/nsSVGForeignObjectFrame.h
layout/svg/nsSVGGFrame.cpp
layout/svg/nsSVGGFrame.h
layout/svg/nsSVGGenericContainerFrame.cpp
layout/svg/nsSVGGenericContainerFrame.h
layout/svg/nsSVGGradientFrame.cpp
layout/svg/nsSVGGradientFrame.h
layout/svg/nsSVGImageFrame.cpp
layout/svg/nsSVGImageFrame.h
layout/svg/nsSVGMarkerFrame.cpp
layout/svg/nsSVGMarkerFrame.h
layout/svg/nsSVGMaskFrame.cpp
layout/svg/nsSVGMaskFrame.h
layout/svg/nsSVGOuterSVGFrame.cpp
layout/svg/nsSVGOuterSVGFrame.h
layout/svg/nsSVGPatternFrame.cpp
layout/svg/nsSVGPatternFrame.h
layout/svg/nsSVGStopFrame.cpp
layout/svg/nsSVGUseFrame.cpp
layout/svg/nsSVGUseFrame.h
layout/svg/nsSVGViewportFrame.cpp
layout/svg/nsSVGViewportFrame.h
layout/tables/nsTableCellFrame.cpp
layout/tables/nsTableCellFrame.h
layout/tables/nsTableRowGroupFrame.h
layout/tools/layout-debug/src/nsLayoutDebuggingTools.cpp
layout/xul/nsBoxFrame.cpp
layout/xul/nsBoxFrame.h
layout/xul/nsDeckFrame.cpp
layout/xul/nsDeckFrame.h
layout/xul/nsImageBoxFrame.cpp
layout/xul/nsImageBoxFrame.h
layout/xul/nsLeafBoxFrame.cpp
layout/xul/nsLeafBoxFrame.h
layout/xul/nsListBoxBodyFrame.cpp
layout/xul/nsListBoxBodyFrame.h
layout/xul/nsMenuBarFrame.cpp
layout/xul/nsMenuBarFrame.h
layout/xul/nsMenuFrame.cpp
layout/xul/nsMenuFrame.h
layout/xul/nsMenuPopupFrame.cpp
layout/xul/nsMenuPopupFrame.h
layout/xul/nsPopupSetFrame.h
layout/xul/nsProgressMeterFrame.cpp
layout/xul/nsProgressMeterFrame.h
layout/xul/nsResizerFrame.h
layout/xul/nsScrollBoxFrame.cpp
layout/xul/nsScrollbarButtonFrame.cpp
layout/xul/nsScrollbarButtonFrame.h
layout/xul/nsScrollbarFrame.cpp
layout/xul/nsScrollbarFrame.h
layout/xul/nsSliderFrame.cpp
layout/xul/nsSliderFrame.h
layout/xul/nsSplitterFrame.cpp
layout/xul/nsSplitterFrame.h
layout/xul/nsTextBoxFrame.cpp
layout/xul/nsTextBoxFrame.h
layout/xul/nsXULLabelFrame.cpp
layout/xul/nsXULLabelFrame.h
layout/xul/nsXULTooltipListener.cpp
layout/xul/tree/nsTreeColFrame.cpp
layout/xul/tree/nsTreeColFrame.h
layout/xul/tree/nsTreeColumns.h
layout/xul/tree/nsTreeContentView.cpp
layout/xul/tree/nsTreeStyleCache.cpp
layout/xul/tree/nsTreeStyleCache.h
layout/xul/tree/nsTreeUtils.cpp
layout/xul/tree/nsTreeUtils.h
mfbt/Attributes.h
netwerk/streamconv/nsStreamConverterService.cpp
netwerk/streamconv/nsStreamConverterService.h
parser/html/nsHtml5AtomTable.cpp
parser/html/nsHtml5AtomTable.h
parser/html/nsHtml5AttributeEntry.h
parser/html/nsHtml5AttributeName.cpp
parser/html/nsHtml5AttributeName.h
parser/html/nsHtml5ElementName.cpp
parser/html/nsHtml5ElementName.h
parser/html/nsHtml5Highlighter.cpp
parser/html/nsHtml5Highlighter.h
parser/html/nsHtml5HtmlAttributes.cpp
parser/html/nsHtml5HtmlAttributes.h
parser/html/nsHtml5MetaScanner.cpp
parser/html/nsHtml5MetaScanner.h
parser/html/nsHtml5Portability.cpp
parser/html/nsHtml5Portability.h
parser/html/nsHtml5StackNode.cpp
parser/html/nsHtml5StackNode.h
parser/html/nsHtml5StateSnapshot.cpp
parser/html/nsHtml5StateSnapshot.h
parser/html/nsHtml5String.cpp
parser/html/nsHtml5String.h
parser/html/nsHtml5StringParser.cpp
parser/html/nsHtml5StringParser.h
parser/html/nsHtml5Tokenizer.cpp
parser/html/nsHtml5Tokenizer.h
parser/html/nsHtml5TreeBuilder.cpp
parser/html/nsHtml5TreeBuilder.h
parser/html/nsHtml5TreeBuilderCppSupplement.h
parser/html/nsHtml5TreeBuilderHSupplement.h
parser/html/nsHtml5TreeOpExecutor.h
parser/html/nsHtml5TreeOperation.cpp
parser/html/nsHtml5TreeOperation.h
parser/html/nsHtml5UTF16Buffer.cpp
parser/html/nsHtml5UTF16Buffer.h
parser/htmlparser/CParserContext.cpp
parser/htmlparser/nsHTMLTags.cpp
parser/htmlparser/nsHTMLTags.h
parser/htmlparser/nsIParser.h
parser/htmlparser/nsParser.cpp
rdf/base/nsIRDFXMLSerializer.idl
rdf/base/nsIRDFXMLSink.idl
rdf/base/nsNameSpaceMap.cpp
rdf/base/nsNameSpaceMap.h
rdf/base/nsRDFContentSink.cpp
rdf/base/nsRDFService.cpp
rdf/base/nsRDFXMLDataSource.cpp
rdf/base/nsRDFXMLSerializer.cpp
rdf/base/nsRDFXMLSerializer.h
toolkit/components/extensions/ExtensionPolicyService.h
toolkit/components/extensions/MatchPattern.cpp
toolkit/components/extensions/MatchPattern.h
toolkit/components/extensions/WebExtensionPolicy.h
toolkit/components/extensions/webrequest/ChannelWrapper.cpp
toolkit/components/extensions/webrequest/ChannelWrapper.h
toolkit/components/extensions/webrequest/StreamFilter.h
toolkit/components/extensions/webrequest/StreamFilterParent.cpp
toolkit/components/extensions/webrequest/WebRequestService.cpp
toolkit/components/extensions/webrequest/WebRequestService.h
toolkit/components/filepicker/nsFileView.cpp
toolkit/components/find/nsFind.cpp
toolkit/components/satchel/nsFormFillController.cpp
toolkit/components/typeaheadfind/nsTypeAheadFind.cpp
tools/jprof/split-profile.py
uriloader/exthandler/nsMIMEInfoImpl.h
widget/BasicEvents.h
widget/MiscEvents.h
widget/android/nsNativeThemeAndroid.cpp
widget/android/nsNativeThemeAndroid.h
widget/cocoa/nsChangeObserver.h
widget/cocoa/nsMenuBarX.mm
widget/cocoa/nsMenuGroupOwnerX.mm
widget/cocoa/nsMenuItemX.mm
widget/cocoa/nsMenuX.mm
widget/cocoa/nsNativeThemeCocoa.h
widget/cocoa/nsNativeThemeCocoa.mm
widget/gtk/nsNativeThemeGTK.cpp
widget/gtk/nsNativeThemeGTK.h
widget/gtk/nsWindow.cpp
widget/gtk/nsWindow.h
widget/nsNativeTheme.cpp
widget/nsNativeTheme.h
widget/windows/KeyboardLayout.cpp
widget/windows/nsNativeThemeWin.cpp
widget/windows/nsNativeThemeWin.h
xpcom/build/XPCOM.h
xpcom/ds/moz.build
xpcom/ds/nsAtom.h
xpcom/ds/nsAtomTable.cpp
xpcom/ds/nsIAtom.h
xpcom/ds/nsStaticAtom.h
xpcom/io/nsAppFileLocationProvider.cpp
xpcom/io/nsDirectoryService.cpp
xpcom/io/nsDirectoryService.h
xpcom/tests/gtest/TestAtoms.cpp
--- a/.gdbinit
+++ b/.gdbinit
@@ -81,17 +81,17 @@ def ps
   set $str = $arg0
   if (sizeof(*$str.mData) == 1 && ($str.mFlags & 1) != 0)
     print $str.mData
   else
     pu $str.mData $str.mLength
   end
 end
 
-# Define a "pa" command to display the string value for an nsIAtom
+# Define a "pa" command to display the string value for an nsAtom
 def pa
   set $atom = $arg0
   if (sizeof(*((&*$atom)->mString)) == 2)
     pu (&*$atom)->mString
   end
 end
 
 # define a "pxul" command to display the type of a XUL element from
--- a/.lldbinit
+++ b/.lldbinit
@@ -17,15 +17,15 @@ script topsrcdir = topsrcdir if locals()
 settings set target.inline-breakpoint-strategy always
 
 # Show the dynamic type of an object when using "expr".  This, for example,
 # will show a variable declared as "nsIFrame *" that points to an nsBlockFrame
 # object as being of type "nsBlockFrame *" rather than "nsIFrame *".
 settings set target.prefer-dynamic-value run-target
 
 # Show the string value in atoms.
-type summary add nsIAtom --summary-string "${var.mString}"
+type summary add nsAtom --summary-string "${var.mString}"
 
 # Show the value of text nodes.
 type summary add nsTextNode --summary-string "${var.mText}"
 
 # Dump the current JS stack.
 command alias js expr DumpJSStack()
--- a/accessible/base/ARIAMap.cpp
+++ b/accessible/base/ARIAMap.cpp
@@ -1225,17 +1225,17 @@ static const EStateRule sWAIUnivStateMap
 
 /**
  * ARIA attribute map for attribute characteristics.
  * @note ARIA attributes that don't have any flags are not included here.
  */
 
 struct AttrCharacteristics
 {
-  nsIAtom** attributeName;
+  nsAtom** attributeName;
   const uint8_t characteristics;
 };
 
 static const AttrCharacteristics gWAIUnivAttrMap[] = {
   {&nsGkAtoms::aria_activedescendant,  ATTR_BYPASSOBJ                               },
   {&nsGkAtoms::aria_atomic,   ATTR_BYPASSOBJ_IF_FALSE | ATTR_VALTOKEN | ATTR_GLOBAL },
   {&nsGkAtoms::aria_busy,                               ATTR_VALTOKEN | ATTR_GLOBAL },
   {&nsGkAtoms::aria_checked,           ATTR_BYPASSOBJ | ATTR_VALTOKEN               }, /* exposes checkable obj attr */
@@ -1356,17 +1356,17 @@ aria::UniversalStatesFor(mozilla::dom::E
   uint32_t index = 0;
   while (MapToState(sWAIUnivStateMap[index], aElement, &state))
     index++;
 
   return state;
 }
 
 uint8_t
-aria::AttrCharacteristicsFor(nsIAtom* aAtom)
+aria::AttrCharacteristicsFor(nsAtom* aAtom)
 {
   for (uint32_t i = 0; i < ArrayLength(gWAIUnivAttrMap); i++)
     if (*gWAIUnivAttrMap[i].attributeName == aAtom)
       return gWAIUnivAttrMap[i].characteristics;
 
   return 0;
 }
 
@@ -1384,17 +1384,17 @@ aria::HasDefinedARIAHidden(nsIContent* a
 
 bool
 AttrIterator::Next(nsAString& aAttrName, nsAString& aAttrValue)
 {
   while (mAttrIdx < mAttrCount) {
     const nsAttrName* attr = mContent->GetAttrNameAt(mAttrIdx);
     mAttrIdx++;
     if (attr->NamespaceEquals(kNameSpaceID_None)) {
-      nsIAtom* attrAtom = attr->Atom();
+      nsAtom* attrAtom = attr->Atom();
       nsDependentAtomString attrStr(attrAtom);
       if (!StringBeginsWith(attrStr, NS_LITERAL_STRING("aria-")))
         continue; // Not ARIA
 
       uint8_t attrFlags = aria::AttrCharacteristicsFor(attrAtom);
       if (attrFlags & ATTR_BYPASSOBJ)
         continue; // No need to handle exposing as obj attribute here
 
--- a/accessible/base/ARIAMap.h
+++ b/accessible/base/ARIAMap.h
@@ -7,17 +7,17 @@
 
 #ifndef mozilla_a11y_aria_ARIAMap_h_
 #define mozilla_a11y_aria_ARIAMap_h_
 
 #include "ARIAStateMap.h"
 #include "mozilla/a11y/AccTypes.h"
 #include "mozilla/a11y/Role.h"
 
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsIContent.h"
 
 class nsINode;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Value constants
 
 /**
@@ -135,33 +135,33 @@ const uint8_t ATTR_GLOBAL = 0x1 << 3;
 /**
  * For each ARIA role, this maps the nsIAccessible information.
  */
 struct nsRoleMapEntry
 {
   /**
    * Return true if matches to the given ARIA role.
    */
-  bool Is(nsIAtom* aARIARole) const
+  bool Is(nsAtom* aARIARole) const
     { return *roleAtom == aARIARole; }
 
   /**
    * Return true if ARIA role has the given accessible type.
    */
   bool IsOfType(mozilla::a11y::AccGenericType aType) const
     { return accTypes & aType; }
 
   /**
    * Return ARIA role.
    */
   const nsDependentAtomString ARIARoleString() const
     { return nsDependentAtomString(*roleAtom); }
 
   // ARIA role: string representation such as "button"
-  nsIAtom** roleAtom;
+  nsAtom** roleAtom;
 
   // Role mapping rule: maps to enum Role
   mozilla::a11y::role role;
 
   // Role rule: whether to use mapped role or native semantics
   bool roleRule;
 
   // Value mapping rule: how to compute accessible value
@@ -269,17 +269,17 @@ uint64_t UniversalStatesFor(mozilla::dom
 
 /**
  * Get the ARIA attribute characteristics for a given ARIA attribute.
  *
  * @param aAtom  ARIA attribute
  * @return       A bitflag representing the attribute characteristics
  *               (see above for possible bit masks, prefixed "ATTR_")
  */
-uint8_t AttrCharacteristicsFor(nsIAtom* aAtom);
+uint8_t AttrCharacteristicsFor(nsAtom* aAtom);
 
 /**
  * Return true if the element has defined aria-hidden.
  */
 bool HasDefinedARIAHidden(nsIContent* aContent);
 
  /**
   * Represents a simple enumerator for iterating through ARIA attributes
--- a/accessible/base/ARIAStateMap.cpp
+++ b/accessible/base/ARIAStateMap.cpp
@@ -15,21 +15,21 @@ using namespace mozilla::a11y;
 using namespace mozilla::a11y::aria;
 
 /**
  * Used to store state map rule data for ARIA attribute of enum type.
  */
 struct EnumTypeData
 {
   // ARIA attribute name.
-  nsIAtom* const mAttrName;
+  nsAtom* const mAttrName;
 
   // States if the attribute value is matched to the enum value. Used as
   // nsIContent::AttrValuesArray, last item must be nullptr.
-  nsIAtom* const* const mValues[4];
+  nsAtom* const* const mValues[4];
 
   // States applied if corresponding enum values are matched.
   const uint64_t mStates[3];
 
   // States to clear in case of match.
   const uint64_t mClearState;
 };
 
@@ -41,26 +41,26 @@ enum ETokenType
 };
 
 /**
  * Used to store state map rule data for ARIA attribute of token type (including
  * mixed value).
  */
 struct TokenTypeData
 {
-  TokenTypeData(nsIAtom* aAttrName, uint32_t aType,
+  TokenTypeData(nsAtom* aAttrName, uint32_t aType,
                 uint64_t aPermanentState,
                 uint64_t aTrueState,
                 uint64_t aFalseState = 0) :
   mAttrName(aAttrName), mType(aType), mPermanentState(aPermanentState),
   mTrueState(aTrueState), mFalseState(aFalseState)
   { }
 
   // ARIA attribute name.
-  nsIAtom* const mAttrName;
+  nsAtom* const mAttrName;
 
   // Type.
   const uint32_t mType;
 
   // State applied if the attribute is defined or mType doesn't have
   // eDefinedIfAbsent flag set.
   const uint64_t mPermanentState;
 
--- a/accessible/base/AccEvent.h
+++ b/accessible/base/AccEvent.h
@@ -511,32 +511,32 @@ private:
 };
 
 /**
  * Accessible object attribute changed event.
  */
 class AccObjectAttrChangedEvent: public AccEvent
 {
 public:
-  AccObjectAttrChangedEvent(Accessible* aAccessible, nsIAtom* aAttribute) :
+  AccObjectAttrChangedEvent(Accessible* aAccessible, nsAtom* aAttribute) :
     AccEvent(::nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED, aAccessible),
     mAttribute(aAttribute) { }
 
   // AccEvent
   static const EventGroup kEventGroup = eObjectAttrChangedEvent;
   virtual unsigned int GetEventGroups() const override
   {
     return AccEvent::GetEventGroups() | (1U << eObjectAttrChangedEvent);
   }
 
   // AccObjectAttrChangedEvent
-  nsIAtom* GetAttribute() const { return mAttribute; }
+  nsAtom* GetAttribute() const { return mAttribute; }
 
 private:
-  RefPtr<nsIAtom> mAttribute;
+  RefPtr<nsAtom> mAttribute;
 
   virtual ~AccObjectAttrChangedEvent() { }
 };
 
 /**
  * Downcast the generic accessible event object to derived type.
  */
 class downcast_accEvent
--- a/accessible/base/AccIterator.cpp
+++ b/accessible/base/AccIterator.cpp
@@ -71,22 +71,22 @@ AccIterator::IteratorState::IteratorStat
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // RelatedAccIterator
 ////////////////////////////////////////////////////////////////////////////////
 
 RelatedAccIterator::
   RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
-                     nsIAtom* aRelAttr) :
+                     nsAtom* aRelAttr) :
   mDocument(aDocument), mRelAttr(aRelAttr), mProviders(nullptr),
   mBindingParent(nullptr), mIndex(0)
 {
   mBindingParent = aDependentContent->GetBindingParent();
-  nsIAtom* IDAttr = mBindingParent ?
+  nsAtom* IDAttr = mBindingParent ?
     nsGkAtoms::anonid : nsGkAtoms::id;
 
   nsAutoString id;
   if (aDependentContent->GetAttr(kNameSpaceID_None, IDAttr, id))
     mProviders = mDocument->mDependentIDsHash.Get(id);
 }
 
 Accessible*
@@ -249,17 +249,17 @@ XULDescriptionIterator::Next()
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // IDRefsIterator
 ////////////////////////////////////////////////////////////////////////////////
 
 IDRefsIterator::
   IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
-                 nsIAtom* aIDRefsAttr) :
+                 nsAtom* aIDRefsAttr) :
   mContent(aContent), mDoc(aDoc), mCurrIdx(0)
 {
   if (mContent->IsInUncomposedDoc())
     mContent->GetAttr(kNameSpaceID_None, aIDRefsAttr, mIDs);
 }
 
 const nsDependentSubstring
 IDRefsIterator::NextID()
--- a/accessible/base/AccIterator.h
+++ b/accessible/base/AccIterator.h
@@ -79,32 +79,32 @@ public:
    * @param aDocument         [in] the document accessible the related
    * &                         accessibles belong to.
    * @param aDependentContent [in] the content of dependent accessible that
    *                           relations were requested for
    * @param aRelAttr          [in] relation attribute that relations are
    *                           pointed by
    */
   RelatedAccIterator(DocAccessible* aDocument, nsIContent* aDependentContent,
-                     nsIAtom* aRelAttr);
+                     nsAtom* aRelAttr);
 
   virtual ~RelatedAccIterator() { }
 
   /**
    * Return next related accessible for the given dependent accessible.
    */
   virtual Accessible* Next() override;
 
 private:
   RelatedAccIterator();
   RelatedAccIterator(const RelatedAccIterator&);
   RelatedAccIterator& operator = (const RelatedAccIterator&);
 
   DocAccessible* mDocument;
-  nsIAtom* mRelAttr;
+  nsAtom* mRelAttr;
   DocAccessible::AttrRelProviderArray* mProviders;
   nsIContent* mBindingParent;
   uint32_t mIndex;
 };
 
 
 /**
  * Used to iterate through HTML labels associated with the given accessible.
@@ -214,17 +214,17 @@ private:
  * Used to iterate through IDs, elements or accessibles pointed by IDRefs
  * attribute. Note, any method used to iterate through IDs, elements, or
  * accessibles moves iterator to next position.
  */
 class IDRefsIterator : public AccIterable
 {
 public:
   IDRefsIterator(DocAccessible* aDoc, nsIContent* aContent,
-                 nsIAtom* aIDRefsAttr);
+                 nsAtom* aIDRefsAttr);
   virtual ~IDRefsIterator() { }
 
   /**
    * Return next ID.
    */
   const nsDependentSubstring NextID();
 
   /**
--- a/accessible/base/Logging.cpp
+++ b/accessible/base/Logging.cpp
@@ -848,17 +848,17 @@ logging::Node(const char* aDescr, nsINod
     return;
   }
 
   dom::Element* elm = aNode->AsElement();
 
   nsAutoCString tag;
   elm->NodeInfo()->NameAtom()->ToUTF8String(tag);
 
-  nsIAtom* idAtom = elm->GetID();
+  nsAtom* idAtom = elm->GetID();
   nsAutoCString id;
   if (idAtom)
     idAtom->ToUTF8String(id);
 
   printf("%s: %p, %s@id='%s', idx in parent: %d\n",
          aDescr, static_cast<void*>(elm), tag.get(), id.get(), idxInParent);
 }
 
@@ -914,17 +914,17 @@ logging::AccessibleInfo(const char* aDes
     printf(", text node: %p\n", static_cast<void*>(node));
   }
   else if (node->IsElement()) {
     dom::Element* el = node->AsElement();
 
     nsAutoCString tag;
     el->NodeInfo()->NameAtom()->ToUTF8String(tag);
 
-    nsIAtom* idAtom = el->GetID();
+    nsAtom* idAtom = el->GetID();
     nsAutoCString id;
     if (idAtom) {
       idAtom->ToUTF8String(id);
     }
 
     printf(", element node: %p, %s@id='%s'\n",
            static_cast<void*>(el), tag.get(), id.get());
   }
--- a/accessible/base/nsAccUtils.cpp
+++ b/accessible/base/nsAccUtils.cpp
@@ -20,34 +20,34 @@
 #include "nsIPersistentProperties2.h"
 #include "mozilla/dom/Element.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 void
 nsAccUtils::GetAccAttr(nsIPersistentProperties *aAttributes,
-                       nsIAtom *aAttrName, nsAString& aAttrValue)
+                       nsAtom *aAttrName, nsAString& aAttrValue)
 {
   aAttrValue.Truncate();
 
   aAttributes->GetStringProperty(nsAtomCString(aAttrName), aAttrValue);
 }
 
 void
 nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes,
-                       nsIAtom *aAttrName, const nsAString& aAttrValue)
+                       nsAtom *aAttrName, const nsAString& aAttrValue)
 {
   nsAutoString oldValue;
   aAttributes->SetStringProperty(nsAtomCString(aAttrName), aAttrValue, oldValue);
 }
 
 void
 nsAccUtils::SetAccAttr(nsIPersistentProperties *aAttributes,
-                       nsIAtom* aAttrName, nsIAtom* aAttrValue)
+                       nsAtom* aAttrName, nsAtom* aAttrValue)
 {
   nsAutoString oldValue;
   aAttributes->SetStringProperty(nsAtomCString(aAttrName),
                                  nsAtomString(aAttrValue), oldValue);
 }
 
 void
 nsAccUtils::SetAccGroupAttrs(nsIPersistentProperties *aAttributes,
@@ -182,32 +182,32 @@ nsAccUtils::SetLiveContainerAttributes(n
 
     ancestor = ancestor->GetParent();
     if (!ancestor)
       ancestor = aTopEl; // Use <body>/<frameset>
   }
 }
 
 bool
-nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom)
+nsAccUtils::HasDefinedARIAToken(nsIContent *aContent, nsAtom *aAtom)
 {
   NS_ASSERTION(aContent, "aContent is null in call to HasDefinedARIAToken!");
 
   if (!aContent->HasAttr(kNameSpaceID_None, aAtom) ||
       aContent->AttrValueIs(kNameSpaceID_None, aAtom,
                             nsGkAtoms::_empty, eCaseMatters) ||
       aContent->AttrValueIs(kNameSpaceID_None, aAtom,
                             nsGkAtoms::_undefined, eCaseMatters)) {
         return false;
   }
   return true;
 }
 
-nsIAtom*
-nsAccUtils::GetARIAToken(dom::Element* aElement, nsIAtom* aAttr)
+nsAtom*
+nsAccUtils::GetARIAToken(dom::Element* aElement, nsAtom* aAttr)
 {
   if (!HasDefinedARIAToken(aElement, aAttr))
     return nsGkAtoms::_empty;
 
   static nsIContent::AttrValuesArray tokens[] =
     { &nsGkAtoms::_false, &nsGkAtoms::_true,
       &nsGkAtoms::mixed, nullptr};
 
--- a/accessible/base/nsAccUtils.h
+++ b/accessible/base/nsAccUtils.h
@@ -31,33 +31,33 @@ public:
   /**
    * Returns value of attribute from the given attributes container.
    *
    * @param aAttributes - attributes container
    * @param aAttrName - the name of requested attribute
    * @param aAttrValue - value of attribute
    */
   static void GetAccAttr(nsIPersistentProperties *aAttributes,
-                         nsIAtom *aAttrName,
+                         nsAtom *aAttrName,
                          nsAString& aAttrValue);
 
   /**
    * Set value of attribute for the given attributes container.
    *
    * @param aAttributes - attributes container
    * @param aAttrName - the name of requested attribute
    * @param aAttrValue - new value of attribute
    */
   static void SetAccAttr(nsIPersistentProperties *aAttributes,
-                         nsIAtom *aAttrName,
+                         nsAtom *aAttrName,
                          const nsAString& aAttrValue);
 
   static void SetAccAttr(nsIPersistentProperties *aAttributes,
-                         nsIAtom* aAttrName,
-                         nsIAtom* aAttrValue);
+                         nsAtom* aAttrName,
+                         nsAtom* aAttrValue);
 
   /**
    * Set group attributes ('level', 'setsize', 'posinset').
    */
   static void SetAccGroupAttrs(nsIPersistentProperties *aAttributes,
                                int32_t aLevel, int32_t aSetSize,
                                int32_t aPosInSet);
 
@@ -90,22 +90,22 @@ public:
 
   /**
    * Any ARIA property of type boolean or NMTOKEN is undefined if the ARIA
    * property is not present, or is "" or "undefined". Do not call
    * this method for properties of type string, decimal, IDREF or IDREFS.
    *
    * Return true if the ARIA property is defined, otherwise false
    */
-  static bool HasDefinedARIAToken(nsIContent *aContent, nsIAtom *aAtom);
+  static bool HasDefinedARIAToken(nsIContent *aContent, nsAtom *aAtom);
 
   /**
    * Return atomic value of ARIA attribute of boolean or NMTOKEN type.
    */
-  static nsIAtom* GetARIAToken(mozilla::dom::Element* aElement, nsIAtom* aAttr);
+  static nsAtom* GetARIAToken(mozilla::dom::Element* aElement, nsAtom* aAttr);
 
   /**
    * Return document accessible for the given DOM node.
    */
   static DocAccessible* GetDocAccessibleFor(nsINode* aNode)
   {
     nsIPresShell *presShell = nsCoreUtils::GetPresShellFor(aNode);
     return GetAccService()->GetDocAccessible(presShell);
--- a/accessible/base/nsAccessibilityService.cpp
+++ b/accessible/base/nsAccessibilityService.cpp
@@ -107,17 +107,17 @@ MustBeAccessible(nsIContent* aContent, D
 {
   if (aContent->GetPrimaryFrame()->IsFocusable())
     return true;
 
   uint32_t attrCount = aContent->GetAttrCount();
   for (uint32_t attrIdx = 0; attrIdx < attrCount; attrIdx++) {
     const nsAttrName* attr = aContent->GetAttrNameAt(attrIdx);
     if (attr->NamespaceEquals(kNameSpaceID_None)) {
-      nsIAtom* attrAtom = attr->Atom();
+      nsAtom* attrAtom = attr->Atom();
       nsDependentAtomString attrStr(attrAtom);
       if (!StringBeginsWith(attrStr, NS_LITERAL_STRING("aria-")))
         continue; // not ARIA
 
       // A global state or a property and in case of token defined.
       uint8_t attrFlags = aria::AttrCharacteristicsFor(attrAtom);
       if ((attrFlags & ATTR_GLOBAL) && (!(attrFlags & ATTR_VALTOKEN) ||
            nsAccUtils::HasDefinedARIAToken(aContent, attrAtom))) {
--- a/accessible/base/nsAccessibilityService.h
+++ b/accessible/base/nsAccessibilityService.h
@@ -48,25 +48,25 @@ SelectionManager* SelectionMgr();
  * Returns the application accessible.
  */
 ApplicationAccessible* ApplicationAcc();
 xpcAccessibleApplication* XPCApplicationAcc();
 
 typedef Accessible* (New_Accessible)(nsIContent* aContent, Accessible* aContext);
 
 struct MarkupAttrInfo {
-  nsIAtom** name;
-  nsIAtom** value;
+  nsAtom** name;
+  nsAtom** value;
 
-  nsIAtom** DOMAttrName;
-  nsIAtom** DOMAttrValue;
+  nsAtom** DOMAttrName;
+  nsAtom** DOMAttrValue;
 };
 
 struct MarkupMapInfo {
-  nsIAtom** tag;
+  nsAtom** tag;
   New_Accessible* new_func;
   a11y::role role;
   MarkupAttrInfo attrs[4];
 };
 
 } // namespace a11y
 } // namespace mozilla
 
@@ -305,17 +305,17 @@ private:
   static mozilla::a11y::ApplicationAccessible* gApplicationAccessible;
   static mozilla::a11y::xpcAccessibleApplication* gXPCApplicationAccessible;
 
   /**
    * Contains a set of accessibility service consumers.
    */
   static uint32_t gConsumers;
 
-  nsDataHashtable<nsPtrHashKey<const nsIAtom>, const mozilla::a11y::MarkupMapInfo*> mMarkupMaps;
+  nsDataHashtable<nsPtrHashKey<const nsAtom>, const mozilla::a11y::MarkupMapInfo*> mMarkupMaps;
 
   friend nsAccessibilityService* GetAccService();
   friend nsAccessibilityService* GetOrCreateAccService(uint32_t);
   friend void MaybeShutdownAccService(uint32_t);
   friend mozilla::a11y::FocusManager* mozilla::a11y::FocusMgr();
   friend mozilla::a11y::SelectionManager* mozilla::a11y::SelectionMgr();
   friend mozilla::a11y::ApplicationAccessible* mozilla::a11y::ApplicationAcc();
   friend mozilla::a11y::xpcAccessibleApplication* mozilla::a11y::XPCApplicationAcc();
--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -454,17 +454,17 @@ nsCoreUtils::IsErrorPage(nsIDocument *aD
 
 bool
 nsCoreUtils::GetID(nsIContent *aContent, nsAString& aID)
 {
   return aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::id, aID);
 }
 
 bool
-nsCoreUtils::GetUIntAttr(nsIContent *aContent, nsIAtom *aAttr, int32_t *aUInt)
+nsCoreUtils::GetUIntAttr(nsIContent *aContent, nsAtom *aAttr, int32_t *aUInt)
 {
   nsAutoString value;
   aContent->GetAttr(kNameSpaceID_None, aAttr, value);
   if (!value.IsEmpty()) {
     nsresult error = NS_OK;
     int32_t integer = value.ToInteger(&error);
     if (NS_SUCCEEDED(error) && integer > 0) {
       *aUInt = integer;
--- a/accessible/base/nsCoreUtils.h
+++ b/accessible/base/nsCoreUtils.h
@@ -215,17 +215,17 @@ public:
    * @return          true if there is an ID set for this node
    */
   static bool GetID(nsIContent *aContent, nsAString& aID);
 
   /**
    * Convert attribute value of the given node to positive integer. If no
    * attribute or wrong value then false is returned.
    */
-  static bool GetUIntAttr(nsIContent *aContent, nsIAtom *aAttr,
+  static bool GetUIntAttr(nsIContent *aContent, nsAtom *aAttr,
                           int32_t* aUInt);
 
   /**
    * Returns language for the given node.
    *
    * @param aContent     [in] the given node
    * @param aRootContent [in] container of the given node
    * @param aLanguage    [out] language
--- a/accessible/base/nsTextEquivUtils.cpp
+++ b/accessible/base/nsTextEquivUtils.cpp
@@ -47,17 +47,17 @@ nsTextEquivUtils::GetNameFromSubtree(Acc
 
   sInitiatorAcc = nullptr;
 
   return NS_OK;
 }
 
 nsresult
 nsTextEquivUtils::GetTextEquivFromIDRefs(Accessible* aAccessible,
-                                         nsIAtom *aIDRefsAttr,
+                                         nsAtom *aIDRefsAttr,
                                          nsAString& aTextEquiv)
 {
   aTextEquiv.Truncate();
 
   nsIContent* content = aAccessible->GetContent();
   if (!content)
     return NS_OK;
 
--- a/accessible/base/nsTextEquivUtils.h
+++ b/accessible/base/nsTextEquivUtils.h
@@ -81,17 +81,17 @@ public:
    * Calculates text equivalent for the given accessible from its IDRefs
    * attribute (like aria-labelledby or aria-describedby).
    *
    * @param aAccessible  [in] the accessible text equivalent is computed for
    * @param aIDRefsAttr  [in] IDRefs attribute on DOM node of the accessible
    * @param aTextEquiv   [out] result text equivalent
    */
   static nsresult GetTextEquivFromIDRefs(Accessible* aAccessible,
-                                         nsIAtom *aIDRefsAttr,
+                                         nsAtom *aIDRefsAttr,
                                          nsAString& aTextEquiv);
 
   /**
    * Calculates the text equivalent from the given content and its subtree if
    * allowed and appends it to the given string.
    *
    * @param aInitiatorAcc  [in] the accessible text equivalent is computed for
    *                       in the end (root accessible of text equivalent
--- a/accessible/generic/Accessible-inl.h
+++ b/accessible/generic/Accessible-inl.h
@@ -30,17 +30,17 @@ Accessible::Role()
 
 inline bool
 Accessible::HasARIARole() const
 {
   return mRoleMapEntryIndex != aria::NO_ROLE_MAP_ENTRY_INDEX;
 }
 
 inline bool
-Accessible::IsARIARole(nsIAtom* aARIARole) const
+Accessible::IsARIARole(nsAtom* aARIARole) const
 {
   const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
   return roleMapEntry && roleMapEntry->Is(aARIARole);
 }
 
 inline bool
 Accessible::HasStrongARIARole() const
 {
--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -56,17 +56,17 @@
 #include "nsIDocShellTreeItem.h"
 #include "nsIScrollableFrame.h"
 #include "nsFocusManager.h"
 
 #include "nsString.h"
 #include "nsUnicharUtils.h"
 #include "nsReadableUtils.h"
 #include "prdtoa.h"
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsIURI.h"
 #include "nsArrayUtils.h"
 #include "nsIMutableArray.h"
 #include "nsIObserverService.h"
 #include "nsIServiceManager.h"
 #include "nsWhitespaceTokenizer.h"
 #include "nsAttrName.h"
 
@@ -928,17 +928,17 @@ Accessible::HandleAccEvent(AccEvent* aEv
 already_AddRefed<nsIPersistentProperties>
 Accessible::Attributes()
 {
   nsCOMPtr<nsIPersistentProperties> attributes = NativeAttributes();
   if (!HasOwnContent() || !mContent->IsElement())
     return attributes.forget();
 
   // 'xml-roles' attribute for landmark.
-  nsIAtom* landmark = LandmarkRole();
+  nsAtom* landmark = LandmarkRole();
   if (landmark) {
     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, landmark);
 
   } else {
     // 'xml-roles' attribute coming from ARIA.
     nsAutoString xmlRoles;
     if (mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::role, xmlRoles))
       nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, xmlRoles);
@@ -1478,17 +1478,17 @@ Accessible::ARIATransformRole(role aRole
                               nsGkAtoms::_true, eCaseMatters)) {
       return roles::PARENT_MENUITEM;
     }
   }
 
   return aRole;
 }
 
-nsIAtom*
+nsAtom*
 Accessible::LandmarkRole() const
 {
   const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
   return roleMapEntry && roleMapEntry->IsOfType(eLandmark) ?
     *(roleMapEntry->roleAtom) : nullptr;
 }
 
 role
@@ -2559,17 +2559,17 @@ Accessible::CurrentItem()
     }
   }
   return nullptr;
 }
 
 void
 Accessible::SetCurrentItem(Accessible* aItem)
 {
-  nsIAtom* id = aItem->GetContent()->GetID();
+  nsAtom* id = aItem->GetContent()->GetID();
   if (id) {
     nsAutoString idStr;
     id->ToString(idStr);
     mContent->SetAttr(kNameSpaceID_None,
                       nsGkAtoms::aria_activedescendant, idStr, true);
   }
 }
 
@@ -2642,17 +2642,17 @@ Accessible::GetSiblingAtOffset(int32_t a
   Accessible* child = mParent->GetChildAt(mIndexInParent + aOffset);
   if (aError && !child)
     *aError = NS_ERROR_UNEXPECTED;
 
   return child;
 }
 
 double
-Accessible::AttrNumericValue(nsIAtom* aAttr) const
+Accessible::AttrNumericValue(nsAtom* aAttr) const
 {
   const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
   if (!roleMapEntry || roleMapEntry->valueRule == eNoValue)
     return UnspecifiedNaN<double>();
 
   nsAutoString attrValue;
   if (!mContent->GetAttr(kNameSpaceID_None, aAttr, attrValue))
     return UnspecifiedNaN<double>();
--- a/accessible/generic/Accessible.h
+++ b/accessible/generic/Accessible.h
@@ -19,17 +19,17 @@
 #include "nsTArray.h"
 #include "nsRefPtrHashtable.h"
 #include "nsRect.h"
 
 struct nsRoleMapEntry;
 
 struct nsRect;
 class nsIFrame;
-class nsIAtom;
+class nsAtom;
 class nsIPersistentProperties;
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class AccEvent;
 class AccGroupInfo;
@@ -227,34 +227,34 @@ public:
    * Return enumerated accessible role (see constants in Role.h).
    */
   mozilla::a11y::role Role();
 
   /**
    * Return true if ARIA role is specified on the element.
    */
   bool HasARIARole() const;
-  bool IsARIARole(nsIAtom* aARIARole) const;
+  bool IsARIARole(nsAtom* aARIARole) const;
   bool HasStrongARIARole() const;
 
   /**
    * Retrun ARIA role map if any.
    */
   const nsRoleMapEntry* ARIARoleMap() const;
 
   /**
    * Return accessible role specified by ARIA (see constants in
    * roles).
    */
   mozilla::a11y::role ARIARole();
 
   /**
    * Return a landmark role if applied.
    */
-  virtual nsIAtom* LandmarkRole() const;
+  virtual nsAtom* LandmarkRole() const;
 
   /**
    * Returns enumerated accessible role from native markup (see constants in
    * Role.h). Doesn't take into account ARIA roles.
    */
   virtual mozilla::a11y::role NativeRole();
 
   /**
@@ -1104,17 +1104,17 @@ protected:
   nsIContent* GetAtomicRegion() const;
 
   /**
    * Return numeric value of the given ARIA attribute, NaN if not applicable.
    *
    * @param aARIAProperty  [in] the ARIA property we're using
    * @return  a numeric value
    */
-  double AttrNumericValue(nsIAtom* aARIAAttr) const;
+  double AttrNumericValue(nsAtom* aARIAAttr) const;
 
   /**
    * Return the action rule based on ARIA enum constants EActionRule
    * (see ARIAMap.h). Used by ActionCount() and ActionNameAt().
    */
   uint32_t GetActionRule() const;
 
   /**
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -57,17 +57,17 @@
 #endif
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Static member initialization
 
-static nsIAtom** kRelationAttrs[] =
+static nsAtom** kRelationAttrs[] =
 {
   &nsGkAtoms::aria_labelledby,
   &nsGkAtoms::aria_describedby,
   &nsGkAtoms::aria_details,
   &nsGkAtoms::aria_owns,
   &nsGkAtoms::aria_controls,
   &nsGkAtoms::aria_flowto,
   &nsGkAtoms::aria_errormessage,
@@ -710,17 +710,17 @@ DocAccessible::OnPivotChanged(nsIAccessi
 NS_IMPL_NSIDOCUMENTOBSERVER_CORE_STUB(DocAccessible)
 NS_IMPL_NSIDOCUMENTOBSERVER_LOAD_STUB(DocAccessible)
 NS_IMPL_NSIDOCUMENTOBSERVER_STYLE_STUB(DocAccessible)
 
 void
 DocAccessible::AttributeWillChange(nsIDocument* aDocument,
                                    dom::Element* aElement,
                                    int32_t aNameSpaceID,
-                                   nsIAtom* aAttribute, int32_t aModType,
+                                   nsAtom* aAttribute, int32_t aModType,
                                    const nsAttrValue* aNewValue)
 {
   Accessible* accessible = GetAccessible(aElement);
   if (!accessible) {
     if (aElement != mContent)
       return;
 
     accessible = this;
@@ -762,17 +762,17 @@ DocAccessible::NativeAnonymousChildListC
                                               nsIContent* aContent,
                                               bool aIsRemove)
 {
 }
 
 void
 DocAccessible::AttributeChanged(nsIDocument* aDocument,
                                 dom::Element* aElement,
-                                int32_t aNameSpaceID, nsIAtom* aAttribute,
+                                int32_t aNameSpaceID, nsAtom* aAttribute,
                                 int32_t aModType,
                                 const nsAttrValue* aOldValue)
 {
   NS_ASSERTION(!IsDefunct(),
                "Attribute changed called on defunct document accessible!");
 
   // Proceed even if the element is not accessible because element may become
   // accessible if it gets certain attribute.
@@ -808,17 +808,17 @@ DocAccessible::AttributeChanged(nsIDocum
       aModType == nsIDOMMutationEvent::ADDITION) {
     AddDependentIDsFor(accessible, aAttribute);
   }
 }
 
 // DocAccessible protected member
 void
 DocAccessible::AttributeChangedImpl(Accessible* aAccessible,
-                                    int32_t aNameSpaceID, nsIAtom* aAttribute)
+                                    int32_t aNameSpaceID, nsAtom* aAttribute)
 {
   // Fire accessible event after short timer, because we need to wait for
   // DOM attribute & resulting layout to actually change. Otherwise,
   // assistive technology will retrieve the wrong state/value/selection info.
 
   // XXX todo
   // We still need to handle special HTML cases here
   // For example, if an <img>'s usemap attribute is modified
@@ -947,17 +947,17 @@ DocAccessible::AttributeChangedImpl(Acce
   if (aAttribute == nsGkAtoms::value) {
     if (aAccessible->IsProgress())
       FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, aAccessible);
   }
 }
 
 // DocAccessible protected member
 void
-DocAccessible::ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute)
+DocAccessible::ARIAAttributeChanged(Accessible* aAccessible, nsAtom* aAttribute)
 {
   // Note: For universal/global ARIA states and properties we don't care if
   // there is an ARIA role present or not.
 
   if (aAttribute == nsGkAtoms::aria_required) {
     RefPtr<AccEvent> event =
       new AccStateChangeEvent(aAccessible, states::REQUIRED);
     FireDelayedEvent(event);
@@ -1575,24 +1575,24 @@ DocAccessible::ProcessLoad()
 
   // Fire busy state change event.
   RefPtr<AccEvent> stateEvent =
     new AccStateChangeEvent(this, states::BUSY, false);
   FireDelayedEvent(stateEvent);
 }
 
 void
-DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsIAtom* aRelAttr)
+DocAccessible::AddDependentIDsFor(Accessible* aRelProvider, nsAtom* aRelAttr)
 {
   dom::Element* relProviderEl = aRelProvider->Elm();
   if (!relProviderEl)
     return;
 
   for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) {
-    nsIAtom* relAttr = *kRelationAttrs[idx];
+    nsAtom* relAttr = *kRelationAttrs[idx];
     if (aRelAttr && aRelAttr != relAttr)
       continue;
 
     if (relAttr == nsGkAtoms::_for) {
       if (!relProviderEl->IsAnyOfHTMLElements(nsGkAtoms::label,
                                                nsGkAtoms::output))
         continue;
 
@@ -1647,24 +1647,24 @@ DocAccessible::AddDependentIDsFor(Access
   }
 
   // Make sure to schedule the tree update if needed.
   mNotificationController->ScheduleProcessing();
 }
 
 void
 DocAccessible::RemoveDependentIDsFor(Accessible* aRelProvider,
-                                     nsIAtom* aRelAttr)
+                                     nsAtom* aRelAttr)
 {
   dom::Element* relProviderElm = aRelProvider->Elm();
   if (!relProviderElm)
     return;
 
   for (uint32_t idx = 0; idx < kRelationAttrsLen; idx++) {
-    nsIAtom* relAttr = *kRelationAttrs[idx];
+    nsAtom* relAttr = *kRelationAttrs[idx];
     if (aRelAttr && aRelAttr != *kRelationAttrs[idx])
       continue;
 
     IDRefsIterator iter(this, relProviderElm, relAttr);
     while (true) {
       const nsDependentSubstring id = iter.NextID();
       if (id.IsEmpty())
         break;
@@ -1688,17 +1688,17 @@ DocAccessible::RemoveDependentIDsFor(Acc
     // check.
     if (aRelAttr)
       break;
   }
 }
 
 bool
 DocAccessible::UpdateAccessibleOnAttrChange(dom::Element* aElement,
-                                            nsIAtom* aAttribute)
+                                            nsAtom* aAttribute)
 {
   if (aAttribute == nsGkAtoms::role) {
     // It is common for js libraries to set the role on the body element after
     // the document has loaded. In this case we just update the role map entry.
     if (mContent == aElement) {
       SetRoleMapEntry(aria::GetRoleMap(aElement));
       if (mIPCDoc) {
         mIPCDoc->SendRoleChangedEvent(Role());
--- a/accessible/generic/DocAccessible.h
+++ b/accessible/generic/DocAccessible.h
@@ -443,56 +443,56 @@ protected:
    * Add dependent IDs pointed by accessible element by relation attribute to
    * cache. If the relation attribute is missed then all relation attributes
    * are checked.
    *
    * @param aRelProvider [in] accessible that element has relation attribute
    * @param aRelAttr     [in, optional] relation attribute
    */
   void AddDependentIDsFor(Accessible* aRelProvider,
-                          nsIAtom* aRelAttr = nullptr);
+                          nsAtom* aRelAttr = nullptr);
 
   /**
    * Remove dependent IDs pointed by accessible element by relation attribute
    * from cache. If the relation attribute is absent then all relation
    * attributes are checked.
    *
    * @param aRelProvider [in] accessible that element has relation attribute
    * @param aRelAttr     [in, optional] relation attribute
    */
   void RemoveDependentIDsFor(Accessible* aRelProvider,
-                             nsIAtom* aRelAttr = nullptr);
+                             nsAtom* aRelAttr = nullptr);
 
   /**
    * Update or recreate an accessible depending on a changed attribute.
    *
    * @param aElement   [in] the element the attribute was changed on
    * @param aAttribute [in] the changed attribute
    * @return            true if an action was taken on the attribute change
    */
   bool UpdateAccessibleOnAttrChange(mozilla::dom::Element* aElement,
-                                    nsIAtom* aAttribute);
+                                    nsAtom* aAttribute);
 
   /**
    * Fire accessible events when attribute is changed.
    *
    * @param aAccessible   [in] accessible the DOM attribute is changed for
    * @param aNameSpaceID  [in] namespace of changed attribute
    * @param aAttribute    [in] changed attribute
    */
   void AttributeChangedImpl(Accessible* aAccessible,
-                            int32_t aNameSpaceID, nsIAtom* aAttribute);
+                            int32_t aNameSpaceID, nsAtom* aAttribute);
 
   /**
    * Fire accessible events when ARIA attribute is changed.
    *
    * @param aAccessible  [in] accesislbe the DOM attribute is changed for
    * @param aAttribute   [in] changed attribute
    */
-  void ARIAAttributeChanged(Accessible* aAccessible, nsIAtom* aAttribute);
+  void ARIAAttributeChanged(Accessible* aAccessible, nsAtom* aAttribute);
 
   /**
    * Process ARIA active-descendant attribute change.
    */
   void ARIAActiveDescendantChanged(Accessible* aAccessible);
 
   /**
    * Update the accessible tree for inserted content.
@@ -621,17 +621,17 @@ protected:
   nsCOMPtr<nsIContent> mAnchorJumpElm;
 
   /**
    * A generic state (see items below) before the attribute value was changed.
    * @see AttributeWillChange and AttributeChanged notifications.
    */
   union {
     // ARIA attribute value
-    nsIAtom* mARIAAttrOldValue;
+    nsAtom* mARIAAttrOldValue;
 
     // True if the accessible state bit was on
     bool mStateBitWasOn;
   };
 
   nsTArray<RefPtr<DocAccessible> > mChildDocuments;
 
   /**
@@ -640,20 +640,20 @@ protected:
   RefPtr<nsAccessiblePivot> mVirtualCursor;
 
   /**
    * A storage class for pairing content with one of its relation attributes.
    */
   class AttrRelProvider
   {
   public:
-    AttrRelProvider(nsIAtom* aRelAttr, nsIContent* aContent) :
+    AttrRelProvider(nsAtom* aRelAttr, nsIContent* aContent) :
       mRelAttr(aRelAttr), mContent(aContent) { }
 
-    nsIAtom* mRelAttr;
+    nsAtom* mRelAttr;
     nsCOMPtr<nsIContent> mContent;
 
   private:
     AttrRelProvider();
     AttrRelProvider(const AttrRelProvider&);
     AttrRelProvider& operator =(const AttrRelProvider&);
   };
 
--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -1125,17 +1125,17 @@ HyperTextAccessible::NativeAttributes()
     GetAccService()->MarkupAttributes(mContent, attributes);
     if (mContent->IsMathMLElement())
       SetMathMLXMLRoles(attributes);
   }
 
   return attributes.forget();
 }
 
-nsIAtom*
+nsAtom*
 HyperTextAccessible::LandmarkRole() const
 {
   if (!HasOwnContent())
     return nullptr;
 
   // For the html landmark elements we expose them like we do ARIA landmarks to
   // make AT navigation schemes "just work".
   if (mContent->IsHTMLElement(nsGkAtoms::nav)) {
--- a/accessible/generic/HyperTextAccessible.h
+++ b/accessible/generic/HyperTextAccessible.h
@@ -49,17 +49,17 @@ const char16_t kForcedNewLineChar = '\n'
 class HyperTextAccessible : public AccessibleWrap
 {
 public:
   HyperTextAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_DECL_ISUPPORTS_INHERITED
 
   // Accessible
-  virtual nsIAtom* LandmarkRole() const override;
+  virtual nsAtom* LandmarkRole() const override;
   virtual int32_t GetLevelInternal() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual mozilla::a11y::role NativeRole() override;
   virtual uint64_t NativeState() override;
 
   virtual void Shutdown() override;
   virtual bool RemoveChild(Accessible* aAccessible) override;
   virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override;
--- a/accessible/html/HTMLElementAccessibles.cpp
+++ b/accessible/html/HTMLElementAccessibles.cpp
@@ -236,17 +236,17 @@ HTMLHeaderOrFooterAccessible::NativeRole
     if (mContent->IsHTMLElement(nsGkAtoms::footer)) {
       return roles::FOOTER;
     }
   }
 
   return roles::SECTION;
 }
 
-nsIAtom*
+nsAtom*
 HTMLHeaderOrFooterAccessible::LandmarkRole() const
 {
   if (!HasOwnContent())
     return nullptr;
 
   a11y::role r = const_cast<HTMLHeaderOrFooterAccessible*>(this)->Role();
   if (r == roles::HEADER) {
     return nsGkAtoms::banner;
--- a/accessible/html/HTMLElementAccessibles.h
+++ b/accessible/html/HTMLElementAccessibles.h
@@ -122,17 +122,17 @@ class HTMLHeaderOrFooterAccessible : pub
 public:
 
   HTMLHeaderOrFooterAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HyperTextAccessibleWrap(aContent, aDoc) {}
 
   NS_DECL_ISUPPORTS_INHERITED
 
   // Accessible
-  virtual nsIAtom* LandmarkRole() const override;
+  virtual nsAtom* LandmarkRole() const override;
   virtual a11y::role NativeRole() override;
 
 protected:
   virtual ~HTMLHeaderOrFooterAccessible() {}
 };
 
 } // namespace a11y
 } // namespace mozilla
--- a/accessible/ipc/ProxyAccessibleShared.h
+++ b/accessible/ipc/ProxyAccessibleShared.h
@@ -55,19 +55,19 @@ nsTArray<ProxyAccessible*> RelationByTyp
 /**
  * Get all relations for this accessible.
  */
 void Relations(nsTArray<RelationType>* aTypes,
     nsTArray<nsTArray<ProxyAccessible*>>* aTargetSets) const;
 
 bool IsSearchbox() const;
 
-nsIAtom* LandmarkRole() const;
+nsAtom* LandmarkRole() const;
 
-nsIAtom* ARIARoleAtom() const;
+nsAtom* ARIARoleAtom() const;
 
 int32_t GetLevelInternal();
 void ScrollTo(uint32_t aScrollType);
 void ScrollToPoint(uint32_t aScrollType, int32_t aX, int32_t aY);
 
 int32_t CaretLineNumber();
 int32_t CaretOffset();
 void SetCaretOffset(int32_t aOffset);
--- a/accessible/ipc/other/DocAccessibleChild.cpp
+++ b/accessible/ipc/other/DocAccessibleChild.cpp
@@ -272,33 +272,33 @@ DocAccessibleChild::RecvIsSearchbox(cons
 mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLandmarkRole(const uint64_t& aID, nsString* aLandmark)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
     return IPC_OK();
   }
 
-  if (nsIAtom* roleAtom = acc->LandmarkRole()) {
+  if (nsAtom* roleAtom = acc->LandmarkRole()) {
     roleAtom->ToString(*aLandmark);
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 DocAccessibleChild::RecvARIARoleAtom(const uint64_t& aID, nsString* aRole)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
     return IPC_OK();
   }
 
   if (const nsRoleMapEntry* roleMap = acc->ARIARoleMap()) {
-    if (nsIAtom* roleAtom = *(roleMap->roleAtom)) {
+    if (nsAtom* roleAtom = *(roleMap->roleAtom)) {
       roleAtom->ToString(*aRole);
     }
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
@@ -1991,17 +1991,17 @@ DocAccessibleChild::RecvDOMNodeID(const 
     return IPC_OK();
   }
 
   nsIContent* content = acc->GetContent();
   if (!content) {
     return IPC_OK();
   }
 
-  nsIAtom* id = content->GetID();
+  nsAtom* id = content->GetID();
   if (id) {
     id->ToString(*aDOMNodeID);
   }
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
--- a/accessible/ipc/other/ProxyAccessible.cpp
+++ b/accessible/ipc/other/ProxyAccessible.cpp
@@ -114,25 +114,25 @@ ProxyAccessible::Relations(nsTArray<Rela
 bool
 ProxyAccessible::IsSearchbox() const
 {
   bool retVal = false;
   Unused << mDoc->SendIsSearchbox(mID, &retVal);
   return retVal;
 }
 
-nsIAtom*
+nsAtom*
 ProxyAccessible::LandmarkRole() const
 {
   nsString landmark;
   Unused << mDoc->SendLandmarkRole(mID, &landmark);
   return NS_GetStaticAtom(landmark);
 }
 
-nsIAtom*
+nsAtom*
 ProxyAccessible::ARIARoleAtom() const
 {
   nsString role;
   Unused << mDoc->SendARIARoleAtom(mID, &role);
   return NS_GetStaticAtom(role);
 }
 
 int32_t
--- a/accessible/mac/mozAccessible.mm
+++ b/accessible/mac/mozAccessible.mm
@@ -728,17 +728,17 @@ ConvertToNSArray(nsTArray<ProxyAccessibl
 }
 
 - (NSString*)subrole
 {
   AccessibleWrap* accWrap = [self getGeckoAccessible];
   ProxyAccessible* proxy = [self getProxyAccessible];
 
   // Deal with landmarks first
-  nsIAtom* landmark = nullptr;
+  nsAtom* landmark = nullptr;
   if (accWrap)
     landmark = accWrap->LandmarkRole();
   else if (proxy)
     landmark = proxy->LandmarkRole();
 
   // HTML Elements treated as landmarks
   // XXX bug 1371712
   if (landmark) {
@@ -765,17 +765,17 @@ ConvertToNSArray(nsTArray<ProxyAccessibl
   // macOS groups the specific landmark types of DPub ARIA into two broad
   // categories with corresponding subroles: Navigation and region/container.
   if (mRole == roles::NAVIGATION)
     return @"AXLandmarkNavigation";
   if (mRole == roles::LANDMARK)
     return @"AXLandmarkRegion";
 
   // Now, deal with widget roles
-  nsIAtom* roleAtom = nullptr;
+  nsAtom* roleAtom = nullptr;
   if (accWrap && accWrap->HasARIARole()) {
     const nsRoleMapEntry* roleMap = accWrap->ARIARoleMap();
     roleAtom = *roleMap->roleAtom;
   }
   if (proxy)
     roleAtom = proxy->ARIARoleAtom();
 
   if (roleAtom) {
--- a/accessible/windows/msaa/GeckoCustom.cpp
+++ b/accessible/windows/msaa/GeckoCustom.cpp
@@ -23,17 +23,17 @@ GeckoCustom::get_anchorCount(long* aCoun
 HRESULT
 GeckoCustom::get_DOMNodeID(BSTR* aID)
 {
   nsIContent* content = mAcc->GetContent();
   if (!content) {
     return S_OK;
   }
 
-  nsIAtom* id = content->GetID();
+  nsAtom* id = content->GetID();
   if (id) {
     nsAutoString idStr;
     id->ToString(idStr);
     *aID = ::SysAllocStringLen(idStr.get(), idStr.Length());
   }
   return S_OK;
 }
 
--- a/accessible/xul/XULSliderAccessible.cpp
+++ b/accessible/xul/XULSliderAccessible.cpp
@@ -138,58 +138,58 @@ XULSliderAccessible::GetSliderElement() 
       GetAnonymousElementByAttribute(mContent, nsGkAtoms::anonid,
                                      NS_LITERAL_STRING("slider"));
   }
 
   return mSliderNode;
 }
 
 nsresult
-XULSliderAccessible::GetSliderAttr(nsIAtom* aName, nsAString& aValue) const
+XULSliderAccessible::GetSliderAttr(nsAtom* aName, nsAString& aValue) const
 {
   aValue.Truncate();
 
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
   nsIContent* sliderElm = GetSliderElement();
   if (sliderElm)
     sliderElm->GetAttr(kNameSpaceID_None, aName, aValue);
 
   return NS_OK;
 }
 
 nsresult
-XULSliderAccessible::SetSliderAttr(nsIAtom* aName, const nsAString& aValue)
+XULSliderAccessible::SetSliderAttr(nsAtom* aName, const nsAString& aValue)
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
   nsIContent* sliderElm = GetSliderElement();
   if (sliderElm)
     sliderElm->SetAttr(kNameSpaceID_None, aName, aValue, true);
 
   return NS_OK;
 }
 
 double
-XULSliderAccessible::GetSliderAttr(nsIAtom* aName) const
+XULSliderAccessible::GetSliderAttr(nsAtom* aName) const
 {
   nsAutoString attrValue;
   nsresult rv = GetSliderAttr(aName, attrValue);
   if (NS_FAILED(rv))
     return UnspecifiedNaN<double>();
 
   nsresult error = NS_OK;
   double value = attrValue.ToDouble(&error);
   return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
 }
 
 bool
-XULSliderAccessible::SetSliderAttr(nsIAtom* aName, double aValue)
+XULSliderAccessible::SetSliderAttr(nsAtom* aName, double aValue)
 {
   nsAutoString value;
   value.AppendFloat(aValue);
 
   return NS_SUCCEEDED(SetSliderAttr(aName, value));
 }
 
 
--- a/accessible/xul/XULSliderAccessible.h
+++ b/accessible/xul/XULSliderAccessible.h
@@ -40,21 +40,21 @@ public:
   virtual bool DoAction(uint8_t aIndex) override;
 
 protected:
   /**
    * Return anonymous slider element.
    */
   nsIContent* GetSliderElement() const;
 
-  nsresult GetSliderAttr(nsIAtom *aName, nsAString& aValue) const;
-  nsresult SetSliderAttr(nsIAtom *aName, const nsAString& aValue);
+  nsresult GetSliderAttr(nsAtom *aName, nsAString& aValue) const;
+  nsresult SetSliderAttr(nsAtom *aName, const nsAString& aValue);
 
-  double GetSliderAttr(nsIAtom *aName) const;
-  bool SetSliderAttr(nsIAtom *aName, double aValue);
+  double GetSliderAttr(nsAtom *aName) const;
+  bool SetSliderAttr(nsAtom *aName, double aValue);
 
 private:
   mutable nsCOMPtr<nsIContent> mSliderNode;
 };
 
 
 /**
  * Used for slider's thumb element.
--- a/caps/BasePrincipal.cpp
+++ b/caps/BasePrincipal.cpp
@@ -344,17 +344,17 @@ BasePrincipal::AddonPolicy()
 {
   if (Is<ContentPrincipal>()) {
     return As<ContentPrincipal>()->AddonPolicy();
   }
   return nullptr;
 }
 
 bool
-BasePrincipal::AddonHasPermission(const nsIAtom* aPerm)
+BasePrincipal::AddonHasPermission(const nsAtom* aPerm)
 {
   if (auto policy = AddonPolicy()) {
     return policy->HasPermission(aPerm);
   }
   return false;
 }
 
 already_AddRefed<BasePrincipal>
--- a/caps/BasePrincipal.h
+++ b/caps/BasePrincipal.h
@@ -7,17 +7,17 @@
 #ifndef mozilla_BasePrincipal_h
 #define mozilla_BasePrincipal_h
 
 #include "nsJSPrincipals.h"
 
 #include "mozilla/Attributes.h"
 #include "mozilla/OriginAttributes.h"
 
-class nsIAtom;
+class nsAtom;
 class nsIContentSecurityPolicy;
 class nsIObjectOutputStream;
 class nsIObjectInputStream;
 class nsIURI;
 
 class ExpandedPrincipal;
 
 namespace mozilla {
@@ -81,17 +81,17 @@ public:
   NS_IMETHOD GetIsSystemPrincipal(bool* aResult) override;
   NS_IMETHOD GetOriginAttributes(JSContext* aCx, JS::MutableHandle<JS::Value> aVal) final;
   NS_IMETHOD GetOriginSuffix(nsACString& aOriginSuffix) final;
   NS_IMETHOD GetAppId(uint32_t* aAppId) final;
   NS_IMETHOD GetIsInIsolatedMozBrowserElement(bool* aIsInIsolatedMozBrowserElement) final;
   NS_IMETHOD GetUserContextId(uint32_t* aUserContextId) final;
   NS_IMETHOD GetPrivateBrowsingId(uint32_t* aPrivateBrowsingId) final;
 
-  virtual bool AddonHasPermission(const nsIAtom* aPerm);
+  virtual bool AddonHasPermission(const nsAtom* aPerm);
 
   virtual bool IsCodebasePrincipal() const { return false; };
 
   static BasePrincipal* Cast(nsIPrincipal* aPrin) { return static_cast<BasePrincipal*>(aPrin); }
 
   static already_AddRefed<BasePrincipal>
   CreateCodebasePrincipal(const nsACString& aOrigin);
 
@@ -153,18 +153,18 @@ protected:
   nsCOMPtr<nsIContentSecurityPolicy> mCSP;
   nsCOMPtr<nsIContentSecurityPolicy> mPreloadCSP;
 
 private:
   static already_AddRefed<BasePrincipal>
   CreateCodebasePrincipal(nsIURI* aURI, const OriginAttributes& aAttrs,
                           const nsACString& aOriginNoSuffix);
 
-  RefPtr<nsIAtom> mOriginNoSuffix;
-  RefPtr<nsIAtom> mOriginSuffix;
+  RefPtr<nsAtom> mOriginNoSuffix;
+  RefPtr<nsAtom> mOriginSuffix;
 
   OriginAttributes mOriginAttributes;
   PrincipalKind mKind;
   bool mHasExplicitDomain;
   bool mInitialized;
 };
 
 inline bool
--- a/caps/ExpandedPrincipal.cpp
+++ b/caps/ExpandedPrincipal.cpp
@@ -167,17 +167,17 @@ ExpandedPrincipal::GetBaseDomain(nsACStr
 NS_IMETHODIMP
 ExpandedPrincipal::GetAddonId(nsAString& aAddonId)
 {
   aAddonId.Truncate();
   return NS_OK;
 };
 
 bool
-ExpandedPrincipal::AddonHasPermission(const nsIAtom* aPerm)
+ExpandedPrincipal::AddonHasPermission(const nsAtom* aPerm)
 {
   for (size_t i = 0; i < mPrincipals.Length(); ++i) {
     if (BasePrincipal::Cast(mPrincipals[i])->AddonHasPermission(aPerm)) {
       return true;
     }
   }
   return false;
 }
--- a/caps/ExpandedPrincipal.h
+++ b/caps/ExpandedPrincipal.h
@@ -29,17 +29,17 @@ public:
   NS_IMETHOD_(MozExternalRefCountType) Release() override { return nsJSPrincipals::Release(); };
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
   NS_IMETHOD GetHashValue(uint32_t* aHashValue) override;
   NS_IMETHOD GetURI(nsIURI** aURI) override;
   NS_IMETHOD GetDomain(nsIURI** aDomain) override;
   NS_IMETHOD SetDomain(nsIURI* aDomain) override;
   NS_IMETHOD GetBaseDomain(nsACString& aBaseDomain) override;
   NS_IMETHOD GetAddonId(nsAString& aAddonId) override;
-  virtual bool AddonHasPermission(const nsIAtom* aPerm) override;
+  virtual bool AddonHasPermission(const nsAtom* aPerm) override;
   virtual nsresult GetScriptLocation(nsACString &aStr) override;
 
 protected:
   explicit ExpandedPrincipal(nsTArray<nsCOMPtr<nsIPrincipal>> &aWhiteList);
 
   virtual ~ExpandedPrincipal();
 
   bool SubsumesInternal(nsIPrincipal* aOther,
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -357,17 +357,17 @@ ForEachPing(nsIContent* aContent, ForEac
   //       implemented an interface that exposed an enumeration of nsIURIs.
 
   // Make sure we are dealing with either an <A> or <AREA> element in the HTML
   // or XHTML namespace.
   if (!IsElementAnchor(aContent)) {
     return;
   }
 
-  RefPtr<nsIAtom> pingAtom = NS_Atomize("ping");
+  RefPtr<nsAtom> pingAtom = NS_Atomize("ping");
   if (!pingAtom) {
     return;
   }
 
   nsAutoString value;
   aContent->GetAttr(kNameSpaceID_None, pingAtom, value);
   if (value.IsEmpty()) {
     return;
--- a/docshell/base/nsDocShellTreeOwner.cpp
+++ b/docshell/base/nsDocShellTreeOwner.cpp
@@ -11,17 +11,17 @@
 // Helper Classes
 #include "nsContentUtils.h"
 #include "nsStyleCoord.h"
 #include "nsSize.h"
 #include "mozilla/ReflowInput.h"
 #include "nsIServiceManager.h"
 #include "nsComponentManagerUtils.h"
 #include "nsString.h"
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsReadableUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsISimpleEnumerator.h"
 #include "mozilla/LookAndFeel.h"
 
 // Interfaces needed to be included
 #include "nsPresContext.h"
 #include "nsIContextMenuListener.h"
--- a/docshell/shistory/nsSHEntryShared.cpp
+++ b/docshell/shistory/nsSHEntryShared.cpp
@@ -269,34 +269,34 @@ nsSHEntryShared::CharacterDataChanged(ns
 {
   RemoveFromBFCacheAsync();
 }
 
 void
 nsSHEntryShared::AttributeWillChange(nsIDocument* aDocument,
                                      dom::Element* aContent,
                                      int32_t aNameSpaceID,
-                                     nsIAtom* aAttribute,
+                                     nsAtom* aAttribute,
                                      int32_t aModType,
                                      const nsAttrValue* aNewValue)
 {
 }
 
 void
 nsSHEntryShared::NativeAnonymousChildListChange(nsIDocument* aDocument,
                                                 nsIContent* aContent,
                                                 bool aIsRemove)
 {
 }
 
 void
 nsSHEntryShared::AttributeChanged(nsIDocument* aDocument,
                                   dom::Element* aElement,
                                   int32_t aNameSpaceID,
-                                  nsIAtom* aAttribute,
+                                  nsAtom* aAttribute,
                                   int32_t aModType,
                                   const nsAttrValue* aOldValue)
 {
   RemoveFromBFCacheAsync();
 }
 
 void
 nsSHEntryShared::ContentAppended(nsIDocument* aDocument,
--- a/dom/animation/AnimationUtils.cpp
+++ b/dom/animation/AnimationUtils.cpp
@@ -2,17 +2,17 @@
 /* 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 "AnimationUtils.h"
 
 #include "nsDebug.h"
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsIContent.h"
 #include "nsIDocument.h"
 #include "nsGlobalWindow.h"
 #include "nsString.h"
 #include "xpcpublic.h" // For xpc::NativeGlobal
 #include "mozilla/EffectSet.h"
 #include "mozilla/dom/KeyframeEffectReadOnly.h"
 #include "mozilla/Preferences.h"
@@ -22,17 +22,17 @@ namespace mozilla {
 /* static */ void
 AnimationUtils::LogAsyncAnimationFailure(nsCString& aMessage,
                                          const nsIContent* aContent)
 {
   if (aContent) {
     aMessage.AppendLiteral(" [");
     aMessage.Append(nsAtomCString(aContent->NodeInfo()->NameAtom()));
 
-    nsIAtom* id = aContent->GetID();
+    nsAtom* id = aContent->GetID();
     if (id) {
       aMessage.AppendLiteral(" with id '");
       aMessage.Append(nsAtomCString(aContent->GetID()));
       aMessage.Append('\'');
     }
     aMessage.Append(']');
   }
   aMessage.Append('\n');
--- a/dom/animation/CSSPseudoElement.cpp
+++ b/dom/animation/CSSPseudoElement.cpp
@@ -77,17 +77,17 @@ CSSPseudoElement::Animate(
 /* static */ already_AddRefed<CSSPseudoElement>
 CSSPseudoElement::GetCSSPseudoElement(Element* aElement,
                                       CSSPseudoElementType aType)
 {
   if (!aElement) {
     return nullptr;
   }
 
-  nsIAtom* propName = CSSPseudoElement::GetCSSPseudoElementPropertyAtom(aType);
+  nsAtom* propName = CSSPseudoElement::GetCSSPseudoElementPropertyAtom(aType);
   RefPtr<CSSPseudoElement> pseudo =
     static_cast<CSSPseudoElement*>(aElement->GetProperty(propName));
   if (pseudo) {
     return pseudo.forget();
   }
 
   // CSSPseudoElement is a purely external interface created on-demand, and
   // when all references from script to the pseudo are dropped, we can drop the
@@ -97,17 +97,17 @@ CSSPseudoElement::GetCSSPseudoElement(El
   nsresult rv = aElement->SetProperty(propName, pseudo, nullptr, true);
   if (NS_FAILED(rv)) {
     NS_WARNING("SetProperty failed");
     return nullptr;
   }
   return pseudo.forget();
 }
 
-/* static */ nsIAtom*
+/* static */ nsAtom*
 CSSPseudoElement::GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType)
 {
   switch (aType) {
     case CSSPseudoElementType::before:
       return nsGkAtoms::cssPseudoElementBeforeProperty;
 
     case CSSPseudoElementType::after:
       return nsGkAtoms::cssPseudoElementAfterProperty;
--- a/dom/animation/CSSPseudoElement.h
+++ b/dom/animation/CSSPseudoElement.h
@@ -71,17 +71,17 @@ public:
   // on the element.
   static already_AddRefed<CSSPseudoElement>
     GetCSSPseudoElement(Element* aElement, CSSPseudoElementType aType);
 
 private:
   // Only ::before and ::after are supported.
   CSSPseudoElement(Element* aElement, CSSPseudoElementType aType);
 
-  static nsIAtom* GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType);
+  static nsAtom* GetCSSPseudoElementPropertyAtom(CSSPseudoElementType aType);
 
   // mParentElement needs to be an owning reference since if script is holding
   // on to the pseudo-element, it needs to continue to be able to refer to
   // the parent element.
   RefPtr<Element> mParentElement;
   CSSPseudoElementType mPseudoType;
 };
 
--- a/dom/animation/EffectCompositor.cpp
+++ b/dom/animation/EffectCompositor.cpp
@@ -23,17 +23,17 @@
 #include "mozilla/ServoStyleSet.h"
 #include "mozilla/StyleAnimationValue.h"
 #include "mozilla/TypeTraits.h" // For Forward<>
 #include "nsComputedDOMStyle.h" // nsComputedDOMStyle::GetPresShellForContent
 #include "nsContentUtils.h"
 #include "nsCSSPseudoElements.h"
 #include "nsCSSPropertyIDSet.h"
 #include "nsCSSProps.h"
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsIPresShell.h"
 #include "nsIPresShellInlines.h"
 #include "nsLayoutUtils.h"
 #include "nsRuleNode.h" // For nsRuleNode::ComputePropertiesOverridingAnimation
 #include "nsRuleProcessorData.h" // For ElementRuleProcessorData etc.
 #include "nsStyleContextInlines.h"
 #include "nsTArray.h"
 #include <bitset>
--- a/dom/animation/EffectCompositor.h
+++ b/dom/animation/EffectCompositor.h
@@ -15,17 +15,17 @@
 #include "mozilla/ServoTypes.h"
 #include "nsCSSPropertyID.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsDataHashtable.h"
 #include "nsIStyleRuleProcessor.h"
 #include "nsTArray.h"
 
 class nsCSSPropertyIDSet;
-class nsIAtom;
+class nsAtom;
 class nsIFrame;
 class nsIStyleRule;
 class nsPresContext;
 class nsStyleContext;
 struct RawServoAnimationValueMap;
 typedef RawServoAnimationValueMap* RawServoAnimationValueMapBorrowedMut;
 
 namespace mozilla {
--- a/dom/animation/EffectSet.cpp
+++ b/dom/animation/EffectSet.cpp
@@ -11,17 +11,17 @@
 #include "nsCSSPseudoElements.h" // For CSSPseudoElementType
 #include "nsCycleCollectionNoteChild.h" // For CycleCollectionNoteChild
 #include "nsPresContext.h"
 #include "nsLayoutUtils.h"
 
 namespace mozilla {
 
 /* static */ void
-EffectSet::PropertyDtor(void* aObject, nsIAtom* aPropertyName,
+EffectSet::PropertyDtor(void* aObject, nsAtom* aPropertyName,
                         void* aPropertyValue, void* aData)
 {
   EffectSet* effectSet = static_cast<EffectSet*>(aPropertyValue);
 
 #ifdef DEBUG
   MOZ_ASSERT(!effectSet->mCalledPropertyDtor, "Should not call dtor twice");
   effectSet->mCalledPropertyDtor = true;
 #endif
@@ -41,17 +41,17 @@ EffectSet::Traverse(nsCycleCollectionTra
 /* static */ EffectSet*
 EffectSet::GetEffectSet(const dom::Element* aElement,
                         CSSPseudoElementType aPseudoType)
 {
   if (!aElement->MayHaveAnimations()) {
     return nullptr;
   }
 
-  nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
+  nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
   return static_cast<EffectSet*>(aElement->GetProperty(propName));
 }
 
 /* static */ EffectSet*
 EffectSet::GetEffectSet(const nsIFrame* aFrame)
 {
   Maybe<NonOwningAnimationTarget> target =
     EffectCompositor::GetAnimationElementAndPseudoForFrame(aFrame);
@@ -67,17 +67,17 @@ EffectSet::GetEffectSet(const nsIFrame* 
 EffectSet::GetOrCreateEffectSet(dom::Element* aElement,
                                 CSSPseudoElementType aPseudoType)
 {
   EffectSet* effectSet = GetEffectSet(aElement, aPseudoType);
   if (effectSet) {
     return effectSet;
   }
 
-  nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
+  nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
   effectSet = new EffectSet();
 
   nsresult rv = aElement->SetProperty(propName, effectSet,
                                       &EffectSet::PropertyDtor, true);
   if (NS_FAILED(rv)) {
     NS_WARNING("SetProperty failed");
     // The set must be destroyed via PropertyDtor, otherwise
     // mCalledPropertyDtor assertion is triggered in destructor.
@@ -89,17 +89,17 @@ EffectSet::GetOrCreateEffectSet(dom::Ele
 
   return effectSet;
 }
 
 /* static */ void
 EffectSet::DestroyEffectSet(dom::Element* aElement,
                             CSSPseudoElementType aPseudoType)
 {
-  nsIAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
+  nsAtom* propName = GetEffectSetPropertyAtom(aPseudoType);
   EffectSet* effectSet =
     static_cast<EffectSet*>(aElement->GetProperty(propName));
   if (!effectSet) {
     return;
   }
 
   MOZ_ASSERT(!effectSet->IsBeingEnumerated(),
              "Should not destroy an effect set while it is being enumerated");
@@ -110,31 +110,31 @@ EffectSet::DestroyEffectSet(dom::Element
 
 void
 EffectSet::UpdateAnimationGeneration(nsPresContext* aPresContext)
 {
   mAnimationGeneration =
     aPresContext->RestyleManager()->GetAnimationGeneration();
 }
 
-/* static */ nsIAtom**
+/* static */ nsAtom**
 EffectSet::GetEffectSetPropertyAtoms()
 {
-  static nsIAtom* effectSetPropertyAtoms[] =
+  static nsAtom* effectSetPropertyAtoms[] =
     {
       nsGkAtoms::animationEffectsProperty,
       nsGkAtoms::animationEffectsForBeforeProperty,
       nsGkAtoms::animationEffectsForAfterProperty,
       nullptr
     };
 
   return effectSetPropertyAtoms;
 }
 
-/* static */ nsIAtom*
+/* static */ nsAtom*
 EffectSet::GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType)
 {
   switch (aPseudoType) {
     case CSSPseudoElementType::NotPseudo:
       return nsGkAtoms::animationEffectsProperty;
 
     case CSSPseudoElementType::before:
       return nsGkAtoms::animationEffectsForBeforeProperty;
--- a/dom/animation/EffectSet.h
+++ b/dom/animation/EffectSet.h
@@ -48,17 +48,17 @@ public:
   {
     MOZ_ASSERT(mCalledPropertyDtor,
                "must call destructor through element property dtor");
     MOZ_ASSERT(mActiveIterators == 0,
                "Effect set should not be destroyed while it is being "
                "enumerated");
     MOZ_COUNT_DTOR(EffectSet);
   }
-  static void PropertyDtor(void* aObject, nsIAtom* aPropertyName,
+  static void PropertyDtor(void* aObject, nsAtom* aPropertyName,
                            void* aPropertyValue, void* aData);
 
   // Methods for supporting cycle-collection
   void Traverse(nsCycleCollectionTraversalCallback& aCallback);
 
   static EffectSet* GetEffectSet(const dom::Element* aElement,
                                  CSSPseudoElementType aPseudoType);
   static EffectSet* GetEffectSet(const nsIFrame* aFrame);
@@ -187,33 +187,33 @@ public:
 
   bool CascadeNeedsUpdate() const { return mCascadeNeedsUpdate; }
   void MarkCascadeNeedsUpdate() { mCascadeNeedsUpdate = true; }
   void MarkCascadeUpdated() { mCascadeNeedsUpdate = false; }
 
   void UpdateAnimationGeneration(nsPresContext* aPresContext);
   uint64_t GetAnimationGeneration() const { return mAnimationGeneration; }
 
-  static nsIAtom** GetEffectSetPropertyAtoms();
+  static nsAtom** GetEffectSetPropertyAtoms();
 
   nsCSSPropertyIDSet& PropertiesWithImportantRules()
   {
     return mPropertiesWithImportantRules;
   }
   nsCSSPropertyIDSet& PropertiesForAnimationsLevel()
   {
     return mPropertiesForAnimationsLevel;
   }
   nsCSSPropertyIDSet PropertiesForAnimationsLevel() const
   {
     return mPropertiesForAnimationsLevel;
   }
 
 private:
-  static nsIAtom* GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType);
+  static nsAtom* GetEffectSetPropertyAtom(CSSPseudoElementType aPseudoType);
 
   OwningEffectSet mEffects;
 
   // These style rules contain the style data for currently animating
   // values.  They only match when styling with animation.  When we
   // style without animation, we need to not use them so that we can
   // detect any new changes; if necessary we restyle immediately
   // afterwards with animation.
--- a/dom/animation/KeyframeEffectReadOnly.cpp
+++ b/dom/animation/KeyframeEffectReadOnly.cpp
@@ -1021,17 +1021,17 @@ KeyframeEffectReadOnly::GetTargetStyleCo
   nsIPresShell* shell = GetPresShell();
   if (!shell) {
     return nullptr;
   }
 
   MOZ_ASSERT(mTarget,
              "Should only have a presshell when we have a target element");
 
-  nsIAtom* pseudo = mTarget->mPseudoType < CSSPseudoElementType::Count
+  nsAtom* pseudo = mTarget->mPseudoType < CSSPseudoElementType::Count
                     ? nsCSSPseudoElements::GetPseudoAtom(mTarget->mPseudoType)
                     : nullptr;
 
   return nsComputedDOMStyle::GetStyleContext(mTarget->mElement, pseudo, shell);
 }
 
 #ifdef DEBUG
 void
--- a/dom/asmjscache/AsmJSCache.cpp
+++ b/dom/asmjscache/AsmJSCache.cpp
@@ -23,17 +23,17 @@
 #include "mozilla/dom/quota/UsageInfo.h"
 #include "mozilla/HashFunctions.h"
 #include "mozilla/ipc/BackgroundChild.h"
 #include "mozilla/ipc/BackgroundParent.h"
 #include "mozilla/ipc/BackgroundUtils.h"
 #include "mozilla/ipc/PBackgroundChild.h"
 #include "mozilla/Unused.h"
 #include "nsAutoPtr.h"
-#include "nsIAtom.h"
+#include "nsAtom.h"
 #include "nsIFile.h"
 #include "nsIIPCBackgroundChildCreateCallback.h"
 #include "nsIPrincipal.h"
 #include "nsIRunnable.h"
 #include "nsISimpleEnumerator.h"
 #include "nsIThread.h"
 #include "nsJSPrincipals.h"
 #include "nsThreadUtils.h"
--- a/dom/base/AnonymousContent.cpp
+++ b/dom/base/AnonymousContent.cpp
@@ -182,23 +182,23 @@ AnonymousContent::SetCutoutRectsForEleme
     frame->SchedulePaint();
   }
 }
 
 Element*
 AnonymousContent::GetElementById(const nsAString& aElementId)
 {
   // This can be made faster in the future if needed.
-  RefPtr<nsIAtom> elementId = NS_Atomize(aElementId);
+  RefPtr<nsAtom> elementId = NS_Atomize(aElementId);
   for (nsIContent* node = mContentNode; node;
        node = node->GetNextNode(mContentNode)) {
     if (!node->IsElement()) {
       continue;
     }
-    nsIAtom* id = node->AsElement()->GetID();
+    nsAtom* id = node->AsElement()->GetID();
     if (id && id == elementId) {
       return node->AsElement();
     }
   }
   return nullptr;
 }
 
 bool
--- a/dom/base/Attr.cpp
+++ b/dom/base/Attr.cpp
@@ -159,17 +159,17 @@ Attr::GetName(nsAString& aName)
   return NS_OK;
 }
 
 NS_IMETHODIMP
 Attr::GetValue(nsAString& aValue)
 {
   Element* element = GetElement();
   if (element) {
-    RefPtr<nsIAtom> nameAtom = mNodeInfo->NameAtom();
+    RefPtr<nsAtom> nameAtom = mNodeInfo->NameAtom();
     element->GetAttr(mNodeInfo->NamespaceID(), nameAtom, aValue);
   }
   else {
     aValue = mValue;
   }
 
   return NS_OK;
 }
@@ -178,17 +178,17 @@ void
 Attr::SetValue(const nsAString& aValue, ErrorResult& aRv)
 {
   Element* element = GetElement();
   if (!element) {
     mValue = aValue;
     return;
   }
 
-  RefPtr<nsIAtom> nameAtom = mNodeInfo->NameAtom();
+  RefPtr<nsAtom> nameAtom = mNodeInfo->NameAtom();
   aRv = element->SetAttr(mNodeInfo->NamespaceID(),
                          nameAtom,
                          mNodeInfo->GetPrefixAtom(),
                          aValue,
                          true);
 }
 
 NS_IMETHODIMP
--- a/dom/base/CustomElementRegistry.cpp
+++ b/dom/base/CustomElementRegistry.cpp
@@ -122,22 +122,22 @@ CustomElementConstructor::Construct(cons
     return nullptr;
   }
 
   return element.forget();
 }
 //-----------------------------------------------------
 // CustomElementData
 
-CustomElementData::CustomElementData(nsIAtom* aType)
+CustomElementData::CustomElementData(nsAtom* aType)
   : CustomElementData(aType, CustomElementData::State::eUndefined)
 {
 }
 
-CustomElementData::CustomElementData(nsIAtom* aType, State aState)
+CustomElementData::CustomElementData(nsAtom* aType, State aState)
   : mType(aType)
   , mElementIsBeingCreated(false)
   , mCreatedCallbackInvoked(true)
   , mState(aState)
 {
 }
 
 //-----------------------------------------------------
@@ -225,18 +225,18 @@ CustomElementRegistry::~CustomElementReg
 {
   mozilla::DropJSObjects(this);
 }
 
 CustomElementDefinition*
 CustomElementRegistry::LookupCustomElementDefinition(const nsAString& aLocalName,
                                                      const nsAString* aIs) const
 {
-  RefPtr<nsIAtom> localNameAtom = NS_Atomize(aLocalName);
-  RefPtr<nsIAtom> typeAtom = aIs ? NS_Atomize(*aIs) : localNameAtom;
+  RefPtr<nsAtom> localNameAtom = NS_Atomize(aLocalName);
+  RefPtr<nsAtom> typeAtom = aIs ? NS_Atomize(*aIs) : localNameAtom;
 
   CustomElementDefinition* data = mCustomDefinitions.GetWeak(typeAtom);
   if (data && data->mLocalName == localNameAtom) {
     return data;
   }
 
   return nullptr;
 }
@@ -254,24 +254,24 @@ CustomElementRegistry::LookupCustomEleme
 
   CustomElementDefinition* definition = mCustomDefinitions.GetWeak(ptr->value());
   MOZ_ASSERT(definition, "Definition must be found in mCustomDefinitions");
 
   return definition;
 }
 
 void
-CustomElementRegistry::RegisterUnresolvedElement(Element* aElement, nsIAtom* aTypeName)
+CustomElementRegistry::RegisterUnresolvedElement(Element* aElement, nsAtom* aTypeName)
 {
   mozilla::dom::NodeInfo* info = aElement->NodeInfo();
 
   // Candidate may be a custom element through extension,
   // in which case the custom element type name will not
   // match the element tag name. e.g. <button is="x-button">.
-  RefPtr<nsIAtom> typeName = aTypeName;
+  RefPtr<nsAtom> typeName = aTypeName;
   if (!typeName) {
     typeName = info->NameAtom();
   }
 
   if (mCustomDefinitions.GetWeak(typeName)) {
     return;
   }
 
@@ -280,18 +280,18 @@ CustomElementRegistry::RegisterUnresolve
   *elem = do_GetWeakReference(aElement);
   aElement->AddStates(NS_EVENT_STATE_UNRESOLVED);
 }
 
 void
 CustomElementRegistry::SetupCustomElement(Element* aElement,
                                           const nsAString* aTypeExtension)
 {
-  RefPtr<nsIAtom> tagAtom = aElement->NodeInfo()->NameAtom();
-  RefPtr<nsIAtom> typeAtom = aTypeExtension ?
+  RefPtr<nsAtom> tagAtom = aElement->NodeInfo()->NameAtom();
+  RefPtr<nsAtom> typeAtom = aTypeExtension ?
     NS_Atomize(*aTypeExtension) : tagAtom;
 
   if (aTypeExtension && !aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::is)) {
     // Custom element setup in the parser happens after the "is"
     // attribute is added.
     aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::is, *aTypeExtension, true);
   }
 
@@ -443,44 +443,44 @@ CustomElementRegistry::EnqueueLifecycleC
   }
 
   DocGroup* docGroup = aCustomElement->OwnerDoc()->GetDocGroup();
   if (!docGroup) {
     return;
   }
 
   if (aType == nsIDocument::eAttributeChanged) {
-    RefPtr<nsIAtom> attrName = NS_Atomize(aArgs->name);
+    RefPtr<nsAtom> attrName = NS_Atomize(aArgs->name);
     if (definition->mObservedAttributes.IsEmpty() ||
         !definition->mObservedAttributes.Contains(attrName)) {
       return;
     }
   }
 
   CustomElementReactionsStack* reactionsStack =
     docGroup->CustomElementReactionsStack();
   reactionsStack->EnqueueCallbackReaction(aCustomElement, definition,
                                           Move(callback));
 }
 
 void
-CustomElementRegistry::GetCustomPrototype(nsIAtom* aAtom,
+CustomElementRegistry::GetCustomPrototype(nsAtom* aAtom,
                                           JS::MutableHandle<JSObject*> aPrototype)
 {
   mozilla::dom::CustomElementDefinition* definition =
     mCustomDefinitions.GetWeak(aAtom);
   if (definition) {
     aPrototype.set(definition->mPrototype);
   } else {
     aPrototype.set(nullptr);
   }
 }
 
 void
-CustomElementRegis