Bug 1436508 part 14. Remove nsIDOMMutationEvent. r=masayuki
authorBoris Zbarsky <bzbarsky@mit.edu>
Fri, 09 Feb 2018 11:17:10 -0500
changeset 403186 15f68311633e
parent 403185 2fcaebaeee9f
child 403187 9c5e16dfd42e
push id33416
push userarchaeopteryx@coole-files.de
push dateFri, 09 Feb 2018 22:32:39 +0000
treeherdermozilla-central@c2cddb0cbb20 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmasayuki
bugs1436508
milestone60.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 1436508 part 14. Remove nsIDOMMutationEvent. r=masayuki MozReview-Commit-ID: Gf59kFSIuaK
dom/base/FragmentOrElement.cpp
dom/base/nsDOMMutationObserver.cpp
dom/base/nsIMutationObserver.h
dom/base/nsINode.cpp
dom/base/nsTextNode.cpp
dom/events/MutationEvent.cpp
dom/events/MutationEvent.h
dom/html/HTMLInputElement.cpp
dom/interfaces/events/moz.build
dom/interfaces/events/nsIDOMMutationEvent.idl
layout/generic/nsFrameSetFrame.cpp
layout/generic/nsIFrame.h
layout/generic/nsSubDocumentFrame.cpp
layout/style/nsRuleProcessorData.h
layout/svg/nsSVGImageFrame.h
parser/html/nsHtml5TreeOperation.cpp
xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
--- a/dom/base/FragmentOrElement.cpp
+++ b/dom/base/FragmentOrElement.cpp
@@ -54,17 +54,16 @@
 #include "nsDOMCSSAttrDeclaration.h"
 #include "nsNameSpaceManager.h"
 #include "nsContentList.h"
 #include "nsDOMTokenList.h"
 #include "nsXBLPrototypeBinding.h"
 #include "nsError.h"
 #include "nsDOMString.h"
 #include "nsIScriptSecurityManager.h"
-#include "nsIDOMMutationEvent.h"
 #include "mozilla/InternalMutationEvent.h"
 #include "mozilla/MouseEvents.h"
 #include "nsNodeUtils.h"
 #include "nsDocument.h"
 #include "nsAttrValueOrString.h"
 #ifdef MOZ_XUL
 #include "nsXULElement.h"
 #endif /* MOZ_XUL */
--- a/dom/base/nsDOMMutationObserver.cpp
+++ b/dom/base/nsDOMMutationObserver.cpp
@@ -12,17 +12,16 @@
 
 #include "mozilla/dom/Animation.h"
 #include "mozilla/dom/KeyframeEffectReadOnly.h"
 #include "mozilla/dom/DocGroup.h"
 
 #include "nsContentUtils.h"
 #include "nsCSSPseudoElements.h"
 #include "nsError.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsServiceManagerUtils.h"
 #include "nsTextFragment.h"
 #include "nsThreadUtils.h"
 
 using namespace mozilla;
 
 using mozilla::dom::TreeOrderComparator;
--- a/dom/base/nsIMutationObserver.h
+++ b/dom/base/nsIMutationObserver.h
@@ -152,17 +152,17 @@ public:
    * AttributeChanged).
    *
    * @param aDocument    The owner-document of aContent. Can be null.
    * @param aContent     The element whose attribute will change
    * @param aNameSpaceID The namespace id of the changing attribute
    * @param aAttribute   The name of the changing attribute
    * @param aModType     Whether or not the attribute will be added, changed, or
    *                     removed. The constants are defined in
-   *                     nsIDOMMutationEvent.h.
+   *                     MutationEvent.webidl.
    * @param aNewValue    The new value, IF it has been preparsed by
    *                     BeforeSetAttr, otherwise null.
    *
    * @note Callers of this method might not hold a strong reference to the
    *       observer.  The observer is responsible for making sure it stays
    *       alive for the duration of the call as needed.  The observer may
    *       assume that this call will happen when there are script blockers on
    *       the stack.
@@ -178,17 +178,17 @@ public:
    * Notification that an attribute of an element has changed.
    *
    * @param aDocument    The owner-document of aContent. Can be null.
    * @param aElement     The element whose attribute changed
    * @param aNameSpaceID The namespace id of the changed attribute
    * @param aAttribute   The name of the changed attribute
    * @param aModType     Whether or not the attribute was added, changed, or
    *                     removed. The constants are defined in
-   *                     nsIDOMMutationEvent.h.
+   *                     MutationEvent.webidl.
    * @param aOldValue    The old value, if either the old value or the new
    *                     value are StoresOwnData() (or absent); null otherwise.
    *
    * @note Callers of this method might not hold a strong reference to the
    *       observer.  The observer is responsible for making sure it stays
    *       alive for the duration of the call as needed.  The observer may
    *       assume that this call will happen when there are script blockers on
    *       the stack.
--- a/dom/base/nsINode.cpp
+++ b/dom/base/nsINode.cpp
@@ -57,17 +57,16 @@
 #include "nsICategoryManager.h"
 #include "nsIContentIterator.h"
 #include "nsIControllers.h"
 #include "nsIDocument.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMDocumentType.h"
 #include "nsIDOMEvent.h"
 #include "nsIDOMEventListener.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsIDOMNodeList.h"
 #include "nsILinkHandler.h"
 #include "mozilla/dom/NodeInfo.h"
 #include "mozilla/dom/NodeInfoInlines.h"
 #include "nsIPresShell.h"
 #include "nsIScriptError.h"
 #include "nsIScriptGlobalObject.h"
 #include "nsIScriptSecurityManager.h"
--- a/dom/base/nsTextNode.cpp
+++ b/dom/base/nsTextNode.cpp
@@ -8,17 +8,16 @@
  * Implementation of DOM Core's nsIDOMText node.
  */
 
 #include "nsTextNode.h"
 #include "mozilla/dom/TextBinding.h"
 #include "nsContentUtils.h"
 #include "mozilla/dom/DirectionalityUtils.h"
 #include "nsIDOMEventListener.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsIDocument.h"
 #include "nsThreadUtils.h"
 #include "nsStubMutationObserver.h"
 #include "mozilla/IntegerPrintfMacros.h"
 #ifdef DEBUG
 #include "nsRange.h"
 #endif
 #include "nsDocument.h"
--- a/dom/events/MutationEvent.cpp
+++ b/dom/events/MutationEvent.cpp
@@ -18,105 +18,83 @@ MutationEvent::MutationEvent(EventTarget
                              InternalMutationEvent* aEvent)
   : Event(aOwner, aPresContext,
           aEvent ? aEvent : new InternalMutationEvent(false, eVoidEvent))
 {
   mEventIsInternal = (aEvent == nullptr);
 }
 
 NS_INTERFACE_MAP_BEGIN(MutationEvent)
-  NS_INTERFACE_MAP_ENTRY(nsIDOMMutationEvent)
 NS_INTERFACE_MAP_END_INHERITING(Event)
 
 NS_IMPL_ADDREF_INHERITED(MutationEvent, Event)
 NS_IMPL_RELEASE_INHERITED(MutationEvent, Event)
 
 already_AddRefed<nsINode>
 MutationEvent::GetRelatedNode()
 {
   nsCOMPtr<nsINode> n =
     do_QueryInterface(mEvent->AsMutationEvent()->mRelatedNode);
   return n.forget();
 }
 
-NS_IMETHODIMP
-MutationEvent::GetRelatedNode(nsIDOMNode** aRelatedNode)
-{
-  nsCOMPtr<nsINode> relatedNode = GetRelatedNode();
-  nsCOMPtr<nsIDOMNode> relatedDOMNode = relatedNode ? relatedNode->AsDOMNode() : nullptr;
-  relatedDOMNode.forget(aRelatedNode);
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-MutationEvent::GetPrevValue(nsAString& aPrevValue)
+void
+MutationEvent::GetPrevValue(nsAString& aPrevValue) const
 {
   InternalMutationEvent* mutation = mEvent->AsMutationEvent();
   if (mutation->mPrevAttrValue)
     mutation->mPrevAttrValue->ToString(aPrevValue);
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-MutationEvent::GetNewValue(nsAString& aNewValue)
+void
+MutationEvent::GetNewValue(nsAString& aNewValue) const
 {
   InternalMutationEvent* mutation = mEvent->AsMutationEvent();
   if (mutation->mNewAttrValue)
       mutation->mNewAttrValue->ToString(aNewValue);
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-MutationEvent::GetAttrName(nsAString& aAttrName)
+void
+MutationEvent::GetAttrName(nsAString& aAttrName) const
 {
   InternalMutationEvent* mutation = mEvent->AsMutationEvent();
   if (mutation->mAttrName)
       mutation->mAttrName->ToString(aAttrName);
-  return NS_OK;
 }
 
 uint16_t
 MutationEvent::AttrChange()
 {
   return mEvent->AsMutationEvent()->mAttrChange;
 }
 
-NS_IMETHODIMP
-MutationEvent::GetAttrChange(uint16_t* aAttrChange)
+void
+MutationEvent::InitMutationEvent(const nsAString& aType,
+                                 bool aCanBubble, bool aCancelable,
+                                 nsINode* aRelatedNode,
+                                 const nsAString& aPrevValue,
+                                 const nsAString& aNewValue,
+                                 const nsAString& aAttrName,
+                                 uint16_t& aAttrChange,
+                                 ErrorResult& aRv)
 {
-  *aAttrChange = AttrChange();
-  return NS_OK;
-}
+  NS_ENSURE_TRUE_VOID(!mEvent->mFlags.mIsBeingDispatched);
 
-NS_IMETHODIMP
-MutationEvent::InitMutationEvent(const nsAString& aTypeArg,
-                                 bool aCanBubbleArg,
-                                 bool aCancelableArg,
-                                 nsIDOMNode* aRelatedNodeArg,
-                                 const nsAString& aPrevValueArg,
-                                 const nsAString& aNewValueArg,
-                                 const nsAString& aAttrNameArg,
-                                 uint16_t aAttrChangeArg)
-{
-  NS_ENSURE_TRUE(!mEvent->mFlags.mIsBeingDispatched, NS_OK);
-
-  Event::InitEvent(aTypeArg, aCanBubbleArg, aCancelableArg);
+  Event::InitEvent(aType, aCanBubble, aCancelable);
 
   InternalMutationEvent* mutation = mEvent->AsMutationEvent();
-  mutation->mRelatedNode = aRelatedNodeArg;
-  if (!aPrevValueArg.IsEmpty())
-    mutation->mPrevAttrValue = NS_Atomize(aPrevValueArg);
-  if (!aNewValueArg.IsEmpty())
-    mutation->mNewAttrValue = NS_Atomize(aNewValueArg);
-  if (!aAttrNameArg.IsEmpty()) {
-    mutation->mAttrName = NS_Atomize(aAttrNameArg);
+  mutation->mRelatedNode = aRelatedNode ? aRelatedNode->AsDOMNode() : nullptr;
+  if (!aPrevValue.IsEmpty())
+    mutation->mPrevAttrValue = NS_Atomize(aPrevValue);
+  if (!aNewValue.IsEmpty())
+    mutation->mNewAttrValue = NS_Atomize(aNewValue);
+  if (!aAttrName.IsEmpty()) {
+    mutation->mAttrName = NS_Atomize(aAttrName);
   }
-  mutation->mAttrChange = aAttrChangeArg;
-
-  return NS_OK;
+  mutation->mAttrChange = aAttrChange;
 }
 
 } // namespace dom
 } // namespace mozilla
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
--- a/dom/events/MutationEvent.h
+++ b/dom/events/MutationEvent.h
@@ -5,63 +5,51 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_MutationEvent_h_
 #define mozilla_dom_MutationEvent_h_
 
 #include "mozilla/EventForwards.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/MutationEventBinding.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsINode.h"
 
 namespace mozilla {
 namespace dom {
 
-class MutationEvent : public Event,
-                      public nsIDOMMutationEvent
+class MutationEvent : public Event
 {
 public:
   MutationEvent(EventTarget* aOwner,
                 nsPresContext* aPresContext,
                 InternalMutationEvent* aEvent);
 
   NS_DECL_ISUPPORTS_INHERITED
 
-  NS_DECL_NSIDOMMUTATIONEVENT
-
-  // Forward to base class
-  NS_FORWARD_TO_EVENT
-
   virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override
   {
     return MutationEventBinding::Wrap(aCx, this, aGivenProto);
   }
 
-  // xpidl implementation
-  // GetPrevValue(nsAString& aPrevValue);
-  // GetNewValue(nsAString& aNewValue);
-  // GetAttrName(nsAString& aAttrName);
+  void GetPrevValue(nsAString& aPrevValue) const;
+  void GetNewValue(nsAString& aNewValue) const;
+  void GetAttrName(nsAString& aAttrName) const;
 
   already_AddRefed<nsINode> GetRelatedNode();
 
   uint16_t AttrChange();
 
   void InitMutationEvent(const nsAString& aType,
-                         bool& aCanBubble, bool& aCancelable,
+                         bool aCanBubble, bool aCancelable,
                          nsINode* aRelatedNode,
                          const nsAString& aPrevValue,
                          const nsAString& aNewValue,
                          const nsAString& aAttrName,
-                         uint16_t& aAttrChange, ErrorResult& aRv)
-  {
-    aRv = InitMutationEvent(aType, aCanBubble, aCancelable,
-                            aRelatedNode ? aRelatedNode->AsDOMNode() : nullptr,
-                            aPrevValue, aNewValue, aAttrName, aAttrChange);
-  }
+                         uint16_t& aAttrChange,
+                         ErrorResult& aRv);
 
 protected:
   ~MutationEvent() {}
 };
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -59,17 +59,16 @@
 #include "nsIDOMEvent.h"
 #include "nsIDOMNodeList.h"
 #include "nsLinebreakConverter.h" //to strip out carriage returns
 #include "nsReadableUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsLayoutUtils.h"
 #include "nsVariant.h"
 
-#include "nsIDOMMutationEvent.h"
 #include "mozilla/ContentEvents.h"
 #include "mozilla/EventDispatcher.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/GenericSpecifiedValuesInlines.h"
 #include "mozilla/InternalMutationEvent.h"
 #include "mozilla/TextEditor.h"
 #include "mozilla/TextEvents.h"
 #include "mozilla/TouchEvents.h"
--- a/dom/interfaces/events/moz.build
+++ b/dom/interfaces/events/moz.build
@@ -13,17 +13,16 @@ XPIDL_SOURCES += [
     'nsIDOMDataTransfer.idl',
     'nsIDOMDragEvent.idl',
     'nsIDOMEvent.idl',
     'nsIDOMEventListener.idl',
     'nsIDOMEventTarget.idl',
     'nsIDOMFocusEvent.idl',
     'nsIDOMMouseEvent.idl',
     'nsIDOMMouseScrollEvent.idl',
-    'nsIDOMMutationEvent.idl',
     'nsIDOMNotifyPaintEvent.idl',
     'nsIDOMNSEvent.idl',
     'nsIDOMPaintRequest.idl',
     'nsIDOMScrollAreaEvent.idl',
     'nsIDOMSimpleGestureEvent.idl',
     'nsIDOMTransitionEvent.idl',
     'nsIDOMUIEvent.idl',
     'nsIDOMWheelEvent.idl',
deleted file mode 100644
--- a/dom/interfaces/events/nsIDOMMutationEvent.idl
+++ /dev/null
@@ -1,25 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* 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 "nsISupports.idl"
-#include "nsIDOMNode.idl"
-
-[builtinclass, uuid(30c9997f-bc4c-4890-b890-febb6ae3051b)]
-interface nsIDOMMutationEvent : nsISupports
-{
-  readonly attribute nsIDOMNode       relatedNode;
-  readonly attribute DOMString        prevValue;
-  readonly attribute DOMString        newValue;
-  readonly attribute DOMString        attrName;
-  readonly attribute unsigned short   attrChange;
-  void                      initMutationEvent(in DOMString typeArg,
-                                              in boolean canBubbleArg,
-                                              in boolean cancelableArg,
-                                              in nsIDOMNode relatedNodeArg,
-                                              in DOMString prevValueArg,
-                                              in DOMString newValueArg,
-                                              in DOMString attrNameArg,
-											  in unsigned short attrChangeArg);
-};
--- a/layout/generic/nsFrameSetFrame.cpp
+++ b/layout/generic/nsFrameSetFrame.cpp
@@ -21,17 +21,16 @@
 #include "nsContainerFrame.h"
 #include "nsLayoutUtils.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsGkAtoms.h"
 #include "nsStyleConsts.h"
 #include "nsStyleContext.h"
 #include "nsHTMLParts.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsNameSpaceManager.h"
 #include "nsCSSAnonBoxes.h"
 #include "mozilla/StyleSetHandle.h"
 #include "mozilla/StyleSetHandleInlines.h"
 #include "mozilla/dom/Element.h"
 #include "nsDisplayList.h"
 #include "nsNodeUtils.h"
 #include "mozAutoDocUpdate.h"
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -2065,17 +2065,17 @@ public:
    * This call is invoked when the value of a content objects's attribute
    * is changed.
    * The first frame that maps that content is asked to deal
    * with the change by doing whatever is appropriate.
    *
    * @param aNameSpaceID the namespace of the attribute
    * @param aAttribute the atom name of the attribute
    * @param aModType Whether or not the attribute was added, changed, or removed.
-   *   The constants are defined in nsIDOMMutationEvent.h.
+   *   The constants are defined in MutationEvent.webidl.
    */
   virtual nsresult  AttributeChanged(int32_t         aNameSpaceID,
                                      nsAtom*        aAttribute,
                                      int32_t         aModType) = 0;
 
   /**
    * When the content states of a content object change, this method is invoked
    * on the primary frame of that content object.
--- a/layout/generic/nsSubDocumentFrame.cpp
+++ b/layout/generic/nsSubDocumentFrame.cpp
@@ -36,17 +36,16 @@
 #include "nsIScrollableFrame.h"
 #include "nsIObjectLoadingContent.h"
 #include "nsLayoutUtils.h"
 #include "FrameLayerBuilder.h"
 #include "nsPluginFrame.h"
 #include "nsContentUtils.h"
 #include "nsIPermissionManager.h"
 #include "nsServiceManagerUtils.h"
-#include "nsIDOMMutationEvent.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/HTMLFrameElement.h"
 
 using namespace mozilla;
 using mozilla::layout::RenderFrameParent;
 
 static bool sShowPreviousPage = true;
 
--- a/layout/style/nsRuleProcessorData.h
+++ b/layout/style/nsRuleProcessorData.h
@@ -631,17 +631,17 @@ struct MOZ_STACK_CLASS AttributeRuleProc
       mAttrHasChanged(aAttrHasChanged)
   {
     NS_PRECONDITION(!aTreeMatchContext.mForStyling, "Not styling here!");
   }
   int32_t mNameSpaceID; // Namespace of the attribute involved.
   nsAtom* mAttribute; // |HasAttributeDependentStyle| for which attribute?
   // non-null if we have the value.
   const nsAttrValue* mOtherValue;
-  int32_t mModType;    // The type of modification (see nsIDOMMutationEvent).
+  int32_t mModType;    // The type of modification (see MutationEvent.webidl).
   bool mAttrHasChanged; // Whether the attribute has already changed.
 };
 
 #else
 
 // Define this dummy class so there are fewer call sites to change when the old
 // style system code is compiled out.
 struct TreeMatchContext
--- a/layout/svg/nsSVGImageFrame.h
+++ b/layout/svg/nsSVGImageFrame.h
@@ -8,17 +8,16 @@
 #define __NS_SVGIMAGEFRAME_H__
 
 // Keep in (case-insensitive) order:
 #include "gfxContext.h"
 #include "gfxPlatform.h"
 #include "mozilla/gfx/2D.h"
 #include "imgIContainer.h"
 #include "nsContainerFrame.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsIImageLoadingContent.h"
 #include "nsLayoutUtils.h"
 #include "imgINotificationObserver.h"
 #include "SVGObserverUtils.h"
 #include "nsSVGUtils.h"
 #include "SVGContentUtils.h"
 #include "SVGGeometryFrame.h"
 #include "SVGImageContext.h"
--- a/parser/html/nsHtml5TreeOperation.cpp
+++ b/parser/html/nsHtml5TreeOperation.cpp
@@ -6,17 +6,16 @@
 
 #include "nsHtml5TreeOperation.h"
 #include "nsContentUtils.h"
 #include "nsDocElementCreatedNotificationRunner.h"
 #include "nsINode.h"
 #include "nsNodeUtils.h"
 #include "nsAttrName.h"
 #include "nsHtml5TreeBuilder.h"
-#include "nsIDOMMutationEvent.h"
 #include "mozAutoDocUpdate.h"
 #include "nsBindingManager.h"
 #include "nsXBLBinding.h"
 #include "nsHtml5DocumentMode.h"
 #include "nsHtml5HtmlAttributes.h"
 #include "nsContentCreatorFunctions.h"
 #include "nsIScriptElement.h"
 #include "nsIDTD.h"
--- a/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
@@ -35,17 +35,16 @@
 #include "nsIDOMFormData.h"
 #include "nsIDOMGeoPositionError.h"
 #include "nsIDOMHistory.h"
 #include "nsIDOMHTMLFormElement.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMHTMLMediaElement.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsIDOMMouseScrollEvent.h"
-#include "nsIDOMMutationEvent.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMNodeList.h"
 #include "nsIDOMNotifyPaintEvent.h"
 #include "nsIDOMNSEvent.h"
 #include "nsIDOMOfflineResourceList.h"
 #include "nsIDOMPaintRequest.h"
 #include "nsIDOMParser.h"
 #include "nsIDOMProcessingInstruction.h"
@@ -115,17 +114,16 @@
 #include "mozilla/dom/HTMLInputElementBinding.h"
 #include "mozilla/dom/HTMLMediaElementBinding.h"
 #include "mozilla/dom/ListBoxObjectBinding.h"
 #include "mozilla/dom/MediaListBinding.h"
 #include "mozilla/dom/MessageEventBinding.h"
 #include "mozilla/dom/MenuBoxObjectBinding.h"
 #include "mozilla/dom/MouseEventBinding.h"
 #include "mozilla/dom/MouseScrollEventBinding.h"
-#include "mozilla/dom/MutationEventBinding.h"
 #include "mozilla/dom/NodeListBinding.h"
 #include "mozilla/dom/NodeBinding.h"
 #include "mozilla/dom/NotifyPaintEventBinding.h"
 #include "mozilla/dom/EventBinding.h"
 #include "mozilla/dom/OfflineResourceListBinding.h"
 #include "mozilla/dom/PaintRequestBinding.h"
 #include "mozilla/dom/PositionErrorBinding.h"
 #include "mozilla/dom/ProcessingInstructionBinding.h"
@@ -242,17 +240,16 @@ const ComponentsInterfaceShimEntry kComp
   DEFINE_SHIM(History),
   DEFINE_SHIM(HTMLFormElement),
   DEFINE_SHIM(HTMLInputElement),
   DEFINE_SHIM(HTMLMediaElement),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIListBoxObject, ListBoxObject),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIMenuBoxObject, MenuBoxObject),
   DEFINE_SHIM(MouseEvent),
   DEFINE_SHIM(MouseScrollEvent),
-  DEFINE_SHIM(MutationEvent),
   DEFINE_SHIM(NodeList),
   DEFINE_SHIM(Node),
   DEFINE_SHIM(NotifyPaintEvent),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIDOMNSEvent, Event),
   DEFINE_SHIM(OfflineResourceList),
   DEFINE_SHIM(PaintRequest),
   DEFINE_SHIM_WITH_CUSTOM_INTERFACE(nsIDOMParser, DOMParser),
   DEFINE_SHIM(ProcessingInstruction),