--- a/dom/svg/SVGFEBlendElement.cpp
+++ b/dom/svg/SVGFEBlendElement.cpp
@@ -17,32 +17,32 @@ namespace dom {
 
 JSObject*
 SVGFEBlendElement::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return SVGFEBlendElementBinding::Wrap(aCx, this, aGivenProto);
 }
 
 nsSVGEnumMapping SVGFEBlendElement::sModeMap[] = {
-  {&nsGkAtoms::normal, SVG_FEBLEND_MODE_NORMAL},
-  {&nsGkAtoms::multiply, SVG_FEBLEND_MODE_MULTIPLY},
-  {&nsGkAtoms::screen, SVG_FEBLEND_MODE_SCREEN},
-  {&nsGkAtoms::darken, SVG_FEBLEND_MODE_DARKEN},
-  {&nsGkAtoms::lighten, SVG_FEBLEND_MODE_LIGHTEN},
-  {&nsGkAtoms::overlay, SVG_FEBLEND_MODE_OVERLAY},
-  {&nsGkAtoms::colorDodge, SVG_FEBLEND_MODE_COLOR_DODGE},
-  {&nsGkAtoms::colorBurn, SVG_FEBLEND_MODE_COLOR_BURN},
-  {&nsGkAtoms::hardLight, SVG_FEBLEND_MODE_HARD_LIGHT},
-  {&nsGkAtoms::softLight, SVG_FEBLEND_MODE_SOFT_LIGHT},
-  {&nsGkAtoms::difference, SVG_FEBLEND_MODE_DIFFERENCE},
-  {&nsGkAtoms::exclusion, SVG_FEBLEND_MODE_EXCLUSION},
-  {&nsGkAtoms::hue, SVG_FEBLEND_MODE_HUE},
-  {&nsGkAtoms::saturation, SVG_FEBLEND_MODE_SATURATION},
-  {&nsGkAtoms::color, SVG_FEBLEND_MODE_COLOR},
-  {&nsGkAtoms::luminosity, SVG_FEBLEND_MODE_LUMINOSITY},
+  {nsGkAtoms::normal, SVG_FEBLEND_MODE_NORMAL},
+  {nsGkAtoms::multiply, SVG_FEBLEND_MODE_MULTIPLY},
+  {nsGkAtoms::screen, SVG_FEBLEND_MODE_SCREEN},
+  {nsGkAtoms::darken, SVG_FEBLEND_MODE_DARKEN},
+  {nsGkAtoms::lighten, SVG_FEBLEND_MODE_LIGHTEN},
+  {nsGkAtoms::overlay, SVG_FEBLEND_MODE_OVERLAY},
+  {nsGkAtoms::colorDodge, SVG_FEBLEND_MODE_COLOR_DODGE},
+  {nsGkAtoms::colorBurn, SVG_FEBLEND_MODE_COLOR_BURN},
+  {nsGkAtoms::hardLight, SVG_FEBLEND_MODE_HARD_LIGHT},
+  {nsGkAtoms::softLight, SVG_FEBLEND_MODE_SOFT_LIGHT},
+  {nsGkAtoms::difference, SVG_FEBLEND_MODE_DIFFERENCE},
+  {nsGkAtoms::exclusion, SVG_FEBLEND_MODE_EXCLUSION},
+  {nsGkAtoms::hue, SVG_FEBLEND_MODE_HUE},
+  {nsGkAtoms::saturation, SVG_FEBLEND_MODE_SATURATION},
+  {nsGkAtoms::color, SVG_FEBLEND_MODE_COLOR},
+  {nsGkAtoms::luminosity, SVG_FEBLEND_MODE_LUMINOSITY},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFEBlendElement::sEnumInfo[1] =
 {
   { nsGkAtoms::mode,
     sModeMap,
     SVG_FEBLEND_MODE_NORMAL

--- a/dom/svg/SVGFEColorMatrixElement.cpp
+++ b/dom/svg/SVGFEColorMatrixElement.cpp
@@ -20,20 +20,20 @@ namespace dom {
 
 JSObject*
 SVGFEColorMatrixElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return SVGFEColorMatrixElementBinding::Wrap(aCx, this, aGivenProto);
 }
 
 nsSVGEnumMapping SVGFEColorMatrixElement::sTypeMap[] = {
-  {&nsGkAtoms::matrix, SVG_FECOLORMATRIX_TYPE_MATRIX},
-  {&nsGkAtoms::saturate, SVG_FECOLORMATRIX_TYPE_SATURATE},
-  {&nsGkAtoms::hueRotate, SVG_FECOLORMATRIX_TYPE_HUE_ROTATE},
-  {&nsGkAtoms::luminanceToAlpha, SVG_FECOLORMATRIX_TYPE_LUMINANCE_TO_ALPHA},
+  {nsGkAtoms::matrix, SVG_FECOLORMATRIX_TYPE_MATRIX},
+  {nsGkAtoms::saturate, SVG_FECOLORMATRIX_TYPE_SATURATE},
+  {nsGkAtoms::hueRotate, SVG_FECOLORMATRIX_TYPE_HUE_ROTATE},
+  {nsGkAtoms::luminanceToAlpha, SVG_FECOLORMATRIX_TYPE_LUMINANCE_TO_ALPHA},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFEColorMatrixElement::sEnumInfo[1] =
 {
   { nsGkAtoms::type,
     sTypeMap,
     SVG_FECOLORMATRIX_TYPE_MATRIX

--- a/dom/svg/SVGFECompositeElement.cpp
+++ b/dom/svg/SVGFECompositeElement.cpp
@@ -24,22 +24,22 @@ nsSVGElement::NumberInfo SVGFECompositeE
 {
   { nsGkAtoms::k1, 0, false },
   { nsGkAtoms::k2, 0, false },
   { nsGkAtoms::k3, 0, false },
   { nsGkAtoms::k4, 0, false }
 };
 
 nsSVGEnumMapping SVGFECompositeElement::sOperatorMap[] = {
-  {&nsGkAtoms::over, SVG_FECOMPOSITE_OPERATOR_OVER},
-  {&nsGkAtoms::in, SVG_FECOMPOSITE_OPERATOR_IN},
-  {&nsGkAtoms::out, SVG_FECOMPOSITE_OPERATOR_OUT},
-  {&nsGkAtoms::atop, SVG_FECOMPOSITE_OPERATOR_ATOP},
-  {&nsGkAtoms::xor_, SVG_FECOMPOSITE_OPERATOR_XOR},
-  {&nsGkAtoms::arithmetic, SVG_FECOMPOSITE_OPERATOR_ARITHMETIC},
+  {nsGkAtoms::over, SVG_FECOMPOSITE_OPERATOR_OVER},
+  {nsGkAtoms::in, SVG_FECOMPOSITE_OPERATOR_IN},
+  {nsGkAtoms::out, SVG_FECOMPOSITE_OPERATOR_OUT},
+  {nsGkAtoms::atop, SVG_FECOMPOSITE_OPERATOR_ATOP},
+  {nsGkAtoms::xor_, SVG_FECOMPOSITE_OPERATOR_XOR},
+  {nsGkAtoms::arithmetic, SVG_FECOMPOSITE_OPERATOR_ARITHMETIC},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFECompositeElement::sEnumInfo[1] =
 {
   { nsGkAtoms::_operator,
     sOperatorMap,
     SVG_FECOMPOSITE_OPERATOR_OVER

--- a/dom/svg/SVGFEConvolveMatrixElement.cpp
+++ b/dom/svg/SVGFEConvolveMatrixElement.cpp
@@ -48,19 +48,19 @@ nsSVGElement::IntegerPairInfo SVGFEConvo
 };
 
 nsSVGElement::BooleanInfo SVGFEConvolveMatrixElement::sBooleanInfo[1] =
 {
   { nsGkAtoms::preserveAlpha, false }
 };
 
 nsSVGEnumMapping SVGFEConvolveMatrixElement::sEdgeModeMap[] = {
-  {&nsGkAtoms::duplicate, SVG_EDGEMODE_DUPLICATE},
-  {&nsGkAtoms::wrap, SVG_EDGEMODE_WRAP},
-  {&nsGkAtoms::none, SVG_EDGEMODE_NONE},
+  {nsGkAtoms::duplicate, SVG_EDGEMODE_DUPLICATE},
+  {nsGkAtoms::wrap, SVG_EDGEMODE_WRAP},
+  {nsGkAtoms::none, SVG_EDGEMODE_NONE},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFEConvolveMatrixElement::sEnumInfo[1] =
 {
   { nsGkAtoms::edgeMode,
     sEdgeModeMap,
     SVG_EDGEMODE_DUPLICATE

--- a/dom/svg/SVGFEDisplacementMapElement.cpp
+++ b/dom/svg/SVGFEDisplacementMapElement.cpp
@@ -23,20 +23,20 @@ SVGFEDisplacementMapElement::WrapNode(JS
 }
 
 nsSVGElement::NumberInfo SVGFEDisplacementMapElement::sNumberInfo[1] =
 {
   { nsGkAtoms::scale, 0, false },
 };
 
 nsSVGEnumMapping SVGFEDisplacementMapElement::sChannelMap[] = {
-  {&nsGkAtoms::R, SVG_CHANNEL_R},
-  {&nsGkAtoms::G, SVG_CHANNEL_G},
-  {&nsGkAtoms::B, SVG_CHANNEL_B},
-  {&nsGkAtoms::A, SVG_CHANNEL_A},
+  {nsGkAtoms::R, SVG_CHANNEL_R},
+  {nsGkAtoms::G, SVG_CHANNEL_G},
+  {nsGkAtoms::B, SVG_CHANNEL_B},
+  {nsGkAtoms::A, SVG_CHANNEL_A},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFEDisplacementMapElement::sEnumInfo[2] =
 {
   { nsGkAtoms::xChannelSelector,
     sChannelMap,
     SVG_CHANNEL_A

--- a/dom/svg/SVGFEMorphologyElement.cpp
+++ b/dom/svg/SVGFEMorphologyElement.cpp
@@ -22,18 +22,18 @@ SVGFEMorphologyElement::WrapNode(JSConte
 }
 
 nsSVGElement::NumberPairInfo SVGFEMorphologyElement::sNumberPairInfo[1] =
 {
   { nsGkAtoms::radius, 0, 0 }
 };
 
 nsSVGEnumMapping SVGFEMorphologyElement::sOperatorMap[] = {
-  {&nsGkAtoms::erode, SVG_OPERATOR_ERODE},
-  {&nsGkAtoms::dilate, SVG_OPERATOR_DILATE},
+  {nsGkAtoms::erode, SVG_OPERATOR_ERODE},
+  {nsGkAtoms::dilate, SVG_OPERATOR_DILATE},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFEMorphologyElement::sEnumInfo[1] =
 {
   { nsGkAtoms::_operator,
     sOperatorMap,
     SVG_OPERATOR_ERODE

--- a/dom/svg/SVGFETurbulenceElement.cpp
+++ b/dom/svg/SVGFETurbulenceElement.cpp
@@ -39,27 +39,27 @@ nsSVGElement::NumberPairInfo SVGFETurbul
 };
 
 nsSVGElement::IntegerInfo SVGFETurbulenceElement::sIntegerInfo[1] =
 {
   { nsGkAtoms::numOctaves, 1 }
 };
 
 nsSVGEnumMapping SVGFETurbulenceElement::sTypeMap[] = {
-  {&nsGkAtoms::fractalNoise,
+  {nsGkAtoms::fractalNoise,
    SVG_TURBULENCE_TYPE_FRACTALNOISE},
-  {&nsGkAtoms::turbulence,
+  {nsGkAtoms::turbulence,
    SVG_TURBULENCE_TYPE_TURBULENCE},
   {nullptr, 0}
 };
 
 nsSVGEnumMapping SVGFETurbulenceElement::sStitchTilesMap[] = {
-  {&nsGkAtoms::stitch,
+  {nsGkAtoms::stitch,
    SVG_STITCHTYPE_STITCH},
-  {&nsGkAtoms::noStitch,
+  {nsGkAtoms::noStitch,
    SVG_STITCHTYPE_NOSTITCH},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGFETurbulenceElement::sEnumInfo[2] =
 {
   { nsGkAtoms::type,
     sTypeMap,

--- a/dom/svg/SVGGradientElement.cpp
+++ b/dom/svg/SVGGradientElement.cpp
@@ -24,19 +24,19 @@ namespace mozilla {
 namespace dom {
 
 using namespace SVGGradientElementBinding;
 using namespace SVGUnitTypesBinding;
 
 //--------------------- Gradients------------------------
 
 nsSVGEnumMapping SVGGradientElement::sSpreadMethodMap[] = {
-  {&nsGkAtoms::pad, SVG_SPREADMETHOD_PAD},
-  {&nsGkAtoms::reflect, SVG_SPREADMETHOD_REFLECT},
-  {&nsGkAtoms::repeat, SVG_SPREADMETHOD_REPEAT},
+  {nsGkAtoms::pad, SVG_SPREADMETHOD_PAD},
+  {nsGkAtoms::reflect, SVG_SPREADMETHOD_REFLECT},
+  {nsGkAtoms::repeat, SVG_SPREADMETHOD_REPEAT},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGGradientElement::sEnumInfo[2] =
 {
   { nsGkAtoms::gradientUnits,
     sSVGUnitTypesMap,
     SVG_UNIT_TYPE_OBJECTBOUNDINGBOX

--- a/dom/svg/SVGMarkerElement.cpp
+++ b/dom/svg/SVGMarkerElement.cpp
@@ -39,18 +39,18 @@ nsSVGElement::LengthInfo SVGMarkerElemen
 {
   { nsGkAtoms::refX, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
   { nsGkAtoms::refY, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
   { nsGkAtoms::markerWidth, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X },
   { nsGkAtoms::markerHeight, 3, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::Y },
 };
 
 nsSVGEnumMapping SVGMarkerElement::sUnitsMap[] = {
-  {&nsGkAtoms::strokeWidth, SVG_MARKERUNITS_STROKEWIDTH},
-  {&nsGkAtoms::userSpaceOnUse, SVG_MARKERUNITS_USERSPACEONUSE},
+  {nsGkAtoms::strokeWidth, SVG_MARKERUNITS_STROKEWIDTH},
+  {nsGkAtoms::userSpaceOnUse, SVG_MARKERUNITS_USERSPACEONUSE},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGMarkerElement::sEnumInfo[1] =
 {
   { nsGkAtoms::markerUnits,
     sUnitsMap,
     SVG_MARKERUNITS_STROKEWIDTH

--- a/dom/svg/SVGSVGElement.cpp
+++ b/dom/svg/SVGSVGElement.cpp
@@ -31,18 +31,18 @@ using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace dom {
 
 using namespace SVGPreserveAspectRatioBinding;
 using namespace SVGSVGElementBinding;
 
 nsSVGEnumMapping SVGSVGElement::sZoomAndPanMap[] = {
-  {&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
-  {&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
+  {nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
+  {nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGSVGElement::sEnumInfo[1] =
 {
   { nsGkAtoms::zoomAndPan,
     sZoomAndPanMap,
     SVG_ZOOMANDPAN_MAGNIFY

--- a/dom/svg/SVGTextContentElement.cpp
+++ b/dom/svg/SVGTextContentElement.cpp
@@ -17,18 +17,18 @@
 #include "SVGTextFrame.h"
 
 namespace mozilla {
 namespace dom {
 
 using namespace SVGTextContentElementBinding;
 
 nsSVGEnumMapping SVGTextContentElement::sLengthAdjustMap[] = {
-  { &nsGkAtoms::spacing, LENGTHADJUST_SPACING },
-  { &nsGkAtoms::spacingAndGlyphs, LENGTHADJUST_SPACINGANDGLYPHS },
+  { nsGkAtoms::spacing, LENGTHADJUST_SPACING },
+  { nsGkAtoms::spacingAndGlyphs, LENGTHADJUST_SPACINGANDGLYPHS },
   { nullptr, 0 }
 };
 
 nsSVGElement::EnumInfo SVGTextContentElement::sEnumInfo[1] =
 {
   { nsGkAtoms::lengthAdjust, sLengthAdjustMap, LENGTHADJUST_SPACING }
 };
 

--- a/dom/svg/SVGTextPathElement.cpp
+++ b/dom/svg/SVGTextPathElement.cpp
@@ -32,30 +32,30 @@ nsSVGElement::LengthInfo SVGTextPathElem
 {
   // from SVGTextContentElement:
   { nsGkAtoms::textLength, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::XY },
   // from SVGTextPathElement:
   { nsGkAtoms::startOffset, 0, SVGLengthBinding::SVG_LENGTHTYPE_NUMBER, SVGContentUtils::X }
 };
 
 nsSVGEnumMapping SVGTextPathElement::sMethodMap[] = {
-  {&nsGkAtoms::align, TEXTPATH_METHODTYPE_ALIGN},
-  {&nsGkAtoms::stretch, TEXTPATH_METHODTYPE_STRETCH},
+  {nsGkAtoms::align, TEXTPATH_METHODTYPE_ALIGN},
+  {nsGkAtoms::stretch, TEXTPATH_METHODTYPE_STRETCH},
   {nullptr, 0}
 };
 
 nsSVGEnumMapping SVGTextPathElement::sSpacingMap[] = {
-  {&nsGkAtoms::_auto, TEXTPATH_SPACINGTYPE_AUTO},
-  {&nsGkAtoms::exact, TEXTPATH_SPACINGTYPE_EXACT},
+  {nsGkAtoms::_auto, TEXTPATH_SPACINGTYPE_AUTO},
+  {nsGkAtoms::exact, TEXTPATH_SPACINGTYPE_EXACT},
   {nullptr, 0}
 };
 
 nsSVGEnumMapping SVGTextPathElement::sSideMap[] = {
-  {&nsGkAtoms::left, TEXTPATH_SIDETYPE_LEFT},
-  {&nsGkAtoms::right, TEXTPATH_SIDETYPE_RIGHT},
+  {nsGkAtoms::left, TEXTPATH_SIDETYPE_LEFT},
+  {nsGkAtoms::right, TEXTPATH_SIDETYPE_RIGHT},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGTextPathElement::sEnumInfo[4] =
 {
   // from SVGTextContentElement:
   { nsGkAtoms::lengthAdjust,
     sLengthAdjustMap,

--- a/dom/svg/SVGViewElement.cpp
+++ b/dom/svg/SVGViewElement.cpp
@@ -22,18 +22,18 @@ SVGViewElement::WrapNode(JSContext *aCx,
 }
 
 nsSVGElement::StringListInfo SVGViewElement::sStringListInfo[1] =
 {
   { nsGkAtoms::viewTarget }
 };
 
 nsSVGEnumMapping SVGViewElement::sZoomAndPanMap[] = {
-  {&nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
-  {&nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
+  {nsGkAtoms::disable, SVG_ZOOMANDPAN_DISABLE},
+  {nsGkAtoms::magnify, SVG_ZOOMANDPAN_MAGNIFY},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGViewElement::sEnumInfo[1] =
 {
   { nsGkAtoms::zoomAndPan,
     sZoomAndPanMap,
     SVG_ZOOMANDPAN_MAGNIFY

--- a/dom/svg/nsSVGElement.cpp
+++ b/dom/svg/nsSVGElement.cpp
@@ -82,18 +82,18 @@ NS_NewSVGElement(Element **aResult, alre
 
   it.forget(aResult);
   return rv;
 }
 
 NS_IMPL_ELEMENT_CLONE_WITH_INIT(nsSVGElement)
 
 nsSVGEnumMapping nsSVGElement::sSVGUnitTypesMap[] = {
-  {&nsGkAtoms::userSpaceOnUse, SVG_UNIT_TYPE_USERSPACEONUSE},
-  {&nsGkAtoms::objectBoundingBox, SVG_UNIT_TYPE_OBJECTBOUNDINGBOX},
+  {nsGkAtoms::userSpaceOnUse, SVG_UNIT_TYPE_USERSPACEONUSE},
+  {nsGkAtoms::objectBoundingBox, SVG_UNIT_TYPE_OBJECTBOUNDINGBOX},
   {nullptr, 0}
 };
 
 nsSVGElement::nsSVGElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
   : nsSVGElementBase(aNodeInfo)
 {
 }
 

--- a/dom/svg/nsSVGEnum.cpp
+++ b/dom/svg/nsSVGEnum.cpp
@@ -30,17 +30,17 @@ nsSVGEnum::GetMapping(nsSVGElement *aSVG
 }
 
 nsresult
 nsSVGEnum::SetBaseValueAtom(const nsAtom* aValue, nsSVGElement *aSVGElement)
 {
   const nsSVGEnumMapping* mapping = GetMapping(aSVGElement);
 
   while (mapping && mapping->mKey) {
-    if (aValue == *(mapping->mKey)) {
+    if (aValue == mapping->mKey) {
       mIsBaseSet = true;
       if (mBaseVal != mapping->mVal) {
         mBaseVal = mapping->mVal;
         if (!mIsAnimated) {
           mAnimVal = mBaseVal;
         }
         else {
           aSVGElement->AnimationNeedsResample();
@@ -61,17 +61,17 @@ nsSVGEnum::SetBaseValueAtom(const nsAtom
 
 nsAtom*
 nsSVGEnum::GetBaseValueAtom(nsSVGElement *aSVGElement)
 {
   const nsSVGEnumMapping* mapping = GetMapping(aSVGElement);
 
   while (mapping && mapping->mKey) {
     if (mBaseVal == mapping->mVal) {
-      return *mapping->mKey;
+      return mapping->mKey;
     }
     mapping++;
   }
   NS_ERROR("unknown enumeration value");
   return nsGkAtoms::_empty;
 }
 
 nsresult
@@ -141,17 +141,17 @@ nsSVGEnum::SMILEnum::ValueFromString(con
                                      nsSMILValue& aValue,
                                      bool& aPreventCachingOfSandwich) const
 {
   nsAtom *valAtom = NS_GetStaticAtom(aStr);
   if (valAtom) {
     const nsSVGEnumMapping* mapping = mVal->GetMapping(mSVGElement);
 
     while (mapping && mapping->mKey) {
-      if (valAtom == *(mapping->mKey)) {
+      if (valAtom == mapping->mKey) {
         nsSMILValue val(SMILEnumType::Singleton());
         val.mU.mUint = mapping->mVal;
         aValue = val;
         aPreventCachingOfSandwich = false;
         return NS_OK;
       }
       mapping++;
     }

--- a/dom/svg/nsSVGEnum.h
+++ b/dom/svg/nsSVGEnum.h
@@ -22,18 +22,18 @@ namespace mozilla {
 namespace dom {
 class SVGAnimationElement;
 } // namespace dom
 } // namespace mozilla
 
 typedef uint8_t nsSVGEnumValue;
 
 struct nsSVGEnumMapping {
-  nsStaticAtom** mKey;
-  nsSVGEnumValue mVal;
+  nsStaticAtom* const mKey;
+  const nsSVGEnumValue mVal;
 };
 
 class nsSVGEnum
 {
 public:
   void Init(uint8_t aAttrEnum, uint16_t aValue) {
     mAnimVal = mBaseVal = uint8_t(aValue);
     mAttrEnum = aAttrEnum;

--- a/dom/svg/nsSVGFilters.cpp
+++ b/dom/svg/nsSVGFilters.cpp
@@ -212,25 +212,25 @@ nsSVGElement::NumberInfo SVGComponentTra
   { nsGkAtoms::slope,     1, false },
   { nsGkAtoms::intercept, 0, false },
   { nsGkAtoms::amplitude, 1, false },
   { nsGkAtoms::exponent,  1, false },
   { nsGkAtoms::offset,    0, false }
 };
 
 nsSVGEnumMapping SVGComponentTransferFunctionElement::sTypeMap[] = {
-  {&nsGkAtoms::identity,
+  {nsGkAtoms::identity,
    SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY},
-  {&nsGkAtoms::table,
+  {nsGkAtoms::table,
    SVG_FECOMPONENTTRANSFER_TYPE_TABLE},
-  {&nsGkAtoms::discrete,
+  {nsGkAtoms::discrete,
    SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE},
-  {&nsGkAtoms::linear,
+  {nsGkAtoms::linear,
    SVG_FECOMPONENTTRANSFER_TYPE_LINEAR},
-  {&nsGkAtoms::gamma,
+  {nsGkAtoms::gamma,
    SVG_FECOMPONENTTRANSFER_TYPE_GAMMA},
   {nullptr, 0}
 };
 
 nsSVGElement::EnumInfo SVGComponentTransferFunctionElement::sEnumInfo[1] =
 {
   { nsGkAtoms::type,
     sTypeMap,