--- a/accessible/aom/AccessibleNode.cpp
+++ b/accessible/aom/AccessibleNode.cpp
@@ -57,17 +57,17 @@ AccessibleNode::AccessibleNode(nsINode* 
 
 AccessibleNode::~AccessibleNode()
 {
 }
 
 /* virtual */ JSObject*
 AccessibleNode::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return AccessibleNodeBinding::Wrap(aCx, this, aGivenProto);
+  return AccessibleNode_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 /* virtual */ ParentObject
 AccessibleNode::GetParentObject() const
 {
   return mDOMNode->GetParentObject();
 }
 

--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -138,17 +138,17 @@ nsCoreUtils::DispatchMouseEvent(EventMes
   WidgetMouseEvent event(true, aMessage, aRootWidget,
                          WidgetMouseEvent::eReal, WidgetMouseEvent::eNormal);
 
   event.mRefPoint = LayoutDeviceIntPoint(aX, aY);
 
   event.mClickCount = 1;
   event.button = WidgetMouseEvent::eLeftButton;
   event.mTime = PR_IntervalNow();
-  event.inputSource = dom::MouseEventBinding::MOZ_SOURCE_UNKNOWN;
+  event.inputSource = dom::MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
 
   nsEventStatus status = nsEventStatus_eIgnore;
   aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);
 }
 
 void
 nsCoreUtils::DispatchTouchEvent(EventMessage aMessage, int32_t aX, int32_t aY,
                                 nsIContent* aContent, nsIFrame* aFrame,

--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -250,23 +250,23 @@ Accessible::AccessKey() const
 
   if (!key)
     return KeyBinding();
 
   // Get modifier mask. Use ui.key.generalAccessKey (unless it is -1).
   switch (Preferences::GetInt("ui.key.generalAccessKey", -1)) {
   case -1:
     break;
-  case dom::KeyboardEventBinding::DOM_VK_SHIFT:
+  case dom::KeyboardEvent_Binding::DOM_VK_SHIFT:
     return KeyBinding(key, KeyBinding::kShift);
-  case dom::KeyboardEventBinding::DOM_VK_CONTROL:
+  case dom::KeyboardEvent_Binding::DOM_VK_CONTROL:
     return KeyBinding(key, KeyBinding::kControl);
-  case dom::KeyboardEventBinding::DOM_VK_ALT:
+  case dom::KeyboardEvent_Binding::DOM_VK_ALT:
     return KeyBinding(key, KeyBinding::kAlt);
-  case dom::KeyboardEventBinding::DOM_VK_META:
+  case dom::KeyboardEvent_Binding::DOM_VK_META:
     return KeyBinding(key, KeyBinding::kMeta);
   default:
     return KeyBinding();
   }
 
   // Determine the access modifier used in this context.
   nsIDocument* document = mContent->GetUncomposedDoc();
   if (!document)

--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -712,17 +712,17 @@ DocAccessible::AttributeWillChange(dom::
       return;
 
     accessible = this;
   }
 
   // Update dependent IDs cache. Take care of elements that are accessible
   // because dependent IDs cache doesn't contain IDs from non accessible
   // elements.
-  if (aModType != dom::MutationEventBinding::ADDITION)
+  if (aModType != dom::MutationEvent_Binding::ADDITION)
     RemoveDependentIDsFor(accessible, aAttribute);
 
   if (aAttribute == nsGkAtoms::id) {
     RelocateARIAOwnedIfNeeded(aElement);
   }
 
   // Store the ARIA attribute old value so that it can be used after
   // attribute change. Note, we assume there's no nested ARIA attribute
@@ -730,17 +730,17 @@ DocAccessible::AttributeWillChange(dom::
   // old values.
 
   // XXX TODO: bugs 472142, 472143.
   // Here we will want to cache whatever attribute values we are interested
   // in, such as the existence of aria-pressed for button (so we know if we
   // need to newly expose it as a toggle button) etc.
   if (aAttribute == nsGkAtoms::aria_checked ||
       aAttribute == nsGkAtoms::aria_pressed) {
-    mARIAAttrOldValue = (aModType != dom::MutationEventBinding::ADDITION) ?
+    mARIAAttrOldValue = (aModType != dom::MutationEvent_Binding::ADDITION) ?
       nsAccUtils::GetARIAToken(aElement, aAttribute) : nullptr;
     return;
   }
 
   if (aAttribute == nsGkAtoms::aria_disabled ||
       aAttribute == nsGkAtoms::disabled)
     mStateBitWasOn = accessible->Unavailable();
 }
@@ -785,18 +785,18 @@ DocAccessible::AttributeChanged(dom::Ele
   // the accessible state wasn't changed, i.e. its state is initial state.
   AttributeChangedImpl(accessible, aNameSpaceID, aAttribute);
 
   // Update dependent IDs cache. Take care of accessible elements because no
   // accessible element means either the element is not accessible at all or
   // its accessible will be created later. It doesn't make sense to keep
   // dependent IDs for non accessible elements. For the second case we'll update
   // dependent IDs cache when its accessible is created.
-  if (aModType == dom::MutationEventBinding::MODIFICATION ||
-      aModType == dom::MutationEventBinding::ADDITION) {
+  if (aModType == dom::MutationEvent_Binding::MODIFICATION ||
+      aModType == dom::MutationEvent_Binding::ADDITION) {
     AddDependentIDsFor(accessible, aAttribute);
   }
 }
 
 // DocAccessible protected member
 void
 DocAccessible::AttributeChangedImpl(Accessible* aAccessible,
                                     int32_t aNameSpaceID, nsAtom* aAttribute)

--- a/accessible/xul/XULMenuAccessible.cpp
+++ b/accessible/xul/XULMenuAccessible.cpp
@@ -168,26 +168,26 @@ XULMenuitemAccessible::AccessKey() const
       // If top level menu item, add Alt+ or whatever modifier text to string
       // No need to cache pref service, this happens rarely
       if (gMenuAccesskeyModifier == -1) {
         // Need to initialize cached global accesskey pref
         gMenuAccesskeyModifier = Preferences::GetInt("ui.key.menuAccessKey", 0);
       }
 
       switch (gMenuAccesskeyModifier) {
-        case dom::KeyboardEventBinding::DOM_VK_CONTROL:
+        case dom::KeyboardEvent_Binding::DOM_VK_CONTROL:
           modifierKey = KeyBinding::kControl;
           break;
-        case dom::KeyboardEventBinding::DOM_VK_ALT:
+        case dom::KeyboardEvent_Binding::DOM_VK_ALT:
           modifierKey = KeyBinding::kAlt;
           break;
-        case dom::KeyboardEventBinding::DOM_VK_META:
+        case dom::KeyboardEvent_Binding::DOM_VK_META:
           modifierKey = KeyBinding::kMeta;
           break;
-        case dom::KeyboardEventBinding::DOM_VK_WIN:
+        case dom::KeyboardEvent_Binding::DOM_VK_WIN:
           modifierKey = KeyBinding::kOS;
           break;
       }
     }
   }
 
   return KeyBinding(accesskey[0], modifierKey);
 }

--- a/devtools/shared/heapsnapshot/DominatorTree.cpp
+++ b/devtools/shared/heapsnapshot/DominatorTree.cpp
@@ -128,13 +128,13 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(Dominat
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DominatorTree)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 /* virtual */ JSObject*
 DominatorTree::WrapObject(JSContext* aCx, JS::HandleObject aGivenProto)
 {
-  return dom::DominatorTreeBinding::Wrap(aCx, this, aGivenProto);
+  return dom::DominatorTree_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 } // namespace devtools
 } // namespace mozilla

--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -81,17 +81,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(HeapSna
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HeapSnapshot)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 
 /* virtual */ JSObject*
 HeapSnapshot::WrapObject(JSContext* aCx, HandleObject aGivenProto)
 {
-  return HeapSnapshotBinding::Wrap(aCx, this, aGivenProto);
+  return HeapSnapshot_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 /*** Reading Heap Snapshots ***********************************************************************/
 
 /* static */ already_AddRefed<HeapSnapshot>
 HeapSnapshot::Create(JSContext* cx,
                      GlobalObject& global,
                      const uint8_t* buffer,

--- a/docshell/shistory/ChildSHistory.cpp
+++ b/docshell/shistory/ChildSHistory.cpp
@@ -119,17 +119,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(ChildSH
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ChildSHistory,
                                       mDocShell,
                                       mHistory)
 
 JSObject*
 ChildSHistory::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
 {
-  return ChildSHistoryBinding::Wrap(cx, this, aGivenProto);
+  return ChildSHistory_Binding::Wrap(cx, this, aGivenProto);
 }
 
 nsISupports*
 ChildSHistory::GetParentObject() const
 {
   // We want to get the TabChildGlobal, which is the
   // nsIContentFrameMessageManager on mDocShell.
   nsCOMPtr<nsIContentFrameMessageManager> mm =

--- a/docshell/shistory/ParentSHistory.cpp
+++ b/docshell/shistory/ParentSHistory.cpp
@@ -55,17 +55,17 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(ParentSH
 NS_IMPL_CYCLE_COLLECTING_RELEASE(ParentSHistory)
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ParentSHistory,
                                       mFrameLoader)
 
 JSObject*
 ParentSHistory::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
 {
-  return ParentSHistoryBinding::Wrap(cx, this, aGivenProto);
+  return ParentSHistory_Binding::Wrap(cx, this, aGivenProto);
 }
 
 nsISupports*
 ParentSHistory::GetParentObject() const
 {
   return mFrameLoader;
 }
 

--- a/dom/abort/AbortController.cpp
+++ b/dom/abort/AbortController.cpp
@@ -38,17 +38,17 @@ AbortController::Constructor(const Globa
 AbortController::AbortController(nsIGlobalObject* aGlobal)
   : mGlobal(aGlobal)
   , mAborted(false)
 {}
 
 JSObject*
 AbortController::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return AbortControllerBinding::Wrap(aCx, this, aGivenProto);
+  return AbortController_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 nsIGlobalObject*
 AbortController::GetParentObject() const
 {
   return mGlobal;
 }
 

--- a/dom/abort/AbortSignal.cpp
+++ b/dom/abort/AbortSignal.cpp
@@ -40,17 +40,17 @@ AbortSignal::AbortSignal(AbortController
 
 AbortSignal::AbortSignal(bool aAborted)
   : mAborted(aAborted)
 {}
 
 JSObject*
 AbortSignal::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return AbortSignalBinding::Wrap(aCx, this, aGivenProto);
+  return AbortSignal_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 bool
 AbortSignal::Aborted() const
 {
   return mAborted;
 }
 

--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -38,17 +38,17 @@ NS_IMPL_ADDREF_INHERITED(Animation, DOME
 NS_IMPL_RELEASE_INHERITED(Animation, DOMEventTargetHelper)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Animation)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 
 JSObject*
 Animation::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return dom::AnimationBinding::Wrap(aCx, this, aGivenProto);
+  return dom::Animation_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 // ---------------------------------------------------------------------------
 //
 // Utility methods
 //
 // ---------------------------------------------------------------------------
 

--- a/dom/animation/CSSPseudoElement.cpp
+++ b/dom/animation/CSSPseudoElement.cpp
@@ -42,17 +42,17 @@ ParentObject
 CSSPseudoElement::GetParentObject() const
 {
   return mParentElement->GetParentObject();
 }
 
 JSObject*
 CSSPseudoElement::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return CSSPseudoElementBinding::Wrap(aCx, this, aGivenProto);
+  return CSSPseudoElement_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 void
 CSSPseudoElement::GetAnimations(const AnimationFilter& filter,
                                 nsTArray<RefPtr<Animation>>& aRetVal)
 {
   nsIDocument* doc = mParentElement->GetComposedDoc();
   if (doc) {

--- a/dom/animation/DocumentTimeline.cpp
+++ b/dom/animation/DocumentTimeline.cpp
@@ -40,17 +40,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
 NS_INTERFACE_MAP_END_INHERITING(AnimationTimeline)
 
 NS_IMPL_ADDREF_INHERITED(DocumentTimeline, AnimationTimeline)
 NS_IMPL_RELEASE_INHERITED(DocumentTimeline, AnimationTimeline)
 
 JSObject*
 DocumentTimeline::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
-  return DocumentTimelineBinding::Wrap(aCx, this, aGivenProto);
+  return DocumentTimeline_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 /* static */ already_AddRefed<DocumentTimeline>
 DocumentTimeline::Constructor(const GlobalObject& aGlobal,
                               const DocumentTimelineOptions& aOptions,
                               ErrorResult& aRv)
 {
   nsIDocument* doc = AnimationUtils::GetCurrentRealmDocument(aGlobal.Context());

--- a/dom/animation/KeyframeEffect.cpp
+++ b/dom/animation/KeyframeEffect.cpp
@@ -80,17 +80,17 @@ KeyframeEffect::KeyframeEffect(
   , mCumulativeChangeHint(nsChangeHint(0))
 {
 }
 
 JSObject*
 KeyframeEffect::WrapObject(JSContext* aCx,
                                    JS::Handle<JSObject*> aGivenProto)
 {
-  return KeyframeEffectBinding::Wrap(aCx, this, aGivenProto);
+  return KeyframeEffect_Binding::Wrap(aCx, this, aGivenProto);
 }
 
 IterationCompositeOperation KeyframeEffect::IterationComposite(
   CallerType /*aCallerType*/) const
 {
   return mEffectOptions.mIterationComposite;
 }
 

--- a/dom/base/AnonymousContent.cpp
+++ b/dom/base/AnonymousContent.cpp
@@ -201,17 +201,17 @@ AnonymousContent::GetElementById(const n
   return nullptr;
 }
 
 bool
 AnonymousContent::WrapObject(JSContext* aCx,
                              JS::Handle<JSObject*> aGivenProto,
                              JS::MutableHandle<JSObject*> aReflector)
 {
-  return AnonymousContentBinding::Wrap(aCx, this, aGivenProto, aReflector);
+  return AnonymousContent_Binding::Wrap(aCx, this, aGivenProto, aReflector);
 }
 
 void
 AnonymousContent::GetComputedStylePropertyValue(const nsAString& aElementId,
                                                 const nsAString& aPropertyName,
                                                 DOMString& aResult,
                                                 ErrorResult& aRv)
 {