Backed out changeset 509af1e0771d (bug 1366738) for causing failures in test_WebKitCSSMatrix.html CLOSED TREE
authorMihai Alexandru Michis <malexandru@mozilla.com>
Wed, 03 Jul 2019 10:21:30 +0300
changeset 543912 a70f62521b875857e709f4120006ac2429c869c2
parent 543911 2521756a55f00f7b6a126600a67d64d7e5f86c33
child 543913 6430800a95e1d2101859af8145ed1353c6cf79c9
push id2131
push userffxbld-merge
push dateMon, 26 Aug 2019 18:30:20 +0000
treeherdermozilla-release@b19ffb3ca153 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1366738
milestone69.0a1
backs out509af1e0771d619a0b6d73bffec0583f4f0db9a9
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
Backed out changeset 509af1e0771d (bug 1366738) for causing failures in test_WebKitCSSMatrix.html CLOSED TREE
dom/base/WebKitCSSMatrix.cpp
dom/base/WebKitCSSMatrix.h
dom/base/moz.build
dom/bindings/BindingUtils.cpp
dom/bindings/BindingUtils.h
dom/bindings/Codegen.py
dom/bindings/parser/WebIDL.py
dom/bindings/parser/tests/test_interface.py
dom/webidl/DOMMatrix.webidl
dom/webidl/URL.webidl
dom/webidl/WebKitCSSMatrix.webidl
dom/webidl/moz.build
testing/web-platform/meta/css/geometry/WebKitCSSMatrix.html.ini
testing/web-platform/meta/url/idlharness.any.js.ini
new file mode 100644
--- /dev/null
+++ b/dom/base/WebKitCSSMatrix.cpp
@@ -0,0 +1,167 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "mozilla/dom/WebKitCSSMatrix.h"
+
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/WebKitCSSMatrixBinding.h"
+#include "mozilla/StaticPrefs.h"
+#include "nsPresContext.h"
+#include "nsGlobalWindowInner.h"
+
+namespace mozilla {
+namespace dom {
+
+static const double sRadPerDegree = 2.0 * M_PI / 360.0;
+
+bool WebKitCSSMatrix::FeatureEnabled(JSContext* aCx, JSObject* aObj) {
+  return StaticPrefs::layout_css_DOMMatrix_enabled();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Constructor(
+    const GlobalObject& aGlobal, ErrorResult& aRv) {
+  RefPtr<WebKitCSSMatrix> obj = new WebKitCSSMatrix(aGlobal.GetAsSupports());
+  return obj.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Constructor(
+    const GlobalObject& aGlobal, const nsAString& aTransformList,
+    ErrorResult& aRv) {
+  RefPtr<WebKitCSSMatrix> obj = new WebKitCSSMatrix(aGlobal.GetAsSupports());
+  obj = obj->SetMatrixValue(aTransformList, aRv);
+  return obj.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Constructor(
+    const GlobalObject& aGlobal, const DOMMatrixReadOnly& aOther,
+    ErrorResult& aRv) {
+  RefPtr<WebKitCSSMatrix> obj =
+      new WebKitCSSMatrix(aGlobal.GetAsSupports(), aOther);
+  return obj.forget();
+}
+
+JSObject* WebKitCSSMatrix::WrapObject(JSContext* aCx,
+                                      JS::Handle<JSObject*> aGivenProto) {
+  return WebKitCSSMatrix_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+WebKitCSSMatrix* WebKitCSSMatrix::SetMatrixValue(
+    const nsAString& aTransformList, ErrorResult& aRv) {
+  DOMMatrix::SetMatrixValue(aTransformList, aRv);
+  return this;
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Multiply(
+    const DOMMatrixInit& aOtherInit, ErrorResult& aRv) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->MultiplySelf(aOtherInit, aRv);
+
+  return retval.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Inverse(
+    ErrorResult& aRv) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->InvertSelfThrow(aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  return retval.forget();
+}
+
+WebKitCSSMatrix* WebKitCSSMatrix::InvertSelfThrow(ErrorResult& aRv) {
+  if (mMatrix3D) {
+    if (!mMatrix3D->Invert()) {
+      aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+      return nullptr;
+    }
+  } else if (!mMatrix2D->Invert()) {
+    aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+    return nullptr;
+  }
+
+  return this;
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Translate(double aTx,
+                                                             double aTy,
+                                                             double aTz) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->TranslateSelf(aTx, aTy, aTz);
+
+  return retval.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::Rotate(
+    double aRotX, const Optional<double>& aRotY,
+    const Optional<double>& aRotZ) const {
+  double rotX = aRotX;
+  double rotY;
+  double rotZ;
+
+  if (!aRotY.WasPassed() && !aRotZ.WasPassed()) {
+    rotZ = rotX;
+    rotX = 0;
+    rotY = 0;
+  } else {
+    rotY = aRotY.WasPassed() ? aRotY.Value() : 0;
+    rotZ = aRotZ.WasPassed() ? aRotZ.Value() : 0;
+  }
+
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->Rotate3dSelf(rotX, rotY, rotZ);
+
+  return retval.forget();
+}
+
+WebKitCSSMatrix* WebKitCSSMatrix::Rotate3dSelf(double aRotX, double aRotY,
+                                               double aRotZ) {
+  if (aRotX != 0 || aRotY != 0) {
+    Ensure3DMatrix();
+  }
+
+  if (mMatrix3D) {
+    if (fmod(aRotZ, 360) != 0) {
+      mMatrix3D->RotateZ(aRotZ * sRadPerDegree);
+    }
+    if (fmod(aRotY, 360) != 0) {
+      mMatrix3D->RotateY(aRotY * sRadPerDegree);
+    }
+    if (fmod(aRotX, 360) != 0) {
+      mMatrix3D->RotateX(aRotX * sRadPerDegree);
+    }
+  } else if (fmod(aRotZ, 360) != 0) {
+    mMatrix2D->PreRotate(aRotZ * sRadPerDegree);
+  }
+
+  return this;
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::RotateAxisAngle(
+    double aX, double aY, double aZ, double aAngle) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->RotateAxisAngleSelf(aX, aY, aZ, aAngle);
+
+  return retval.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::SkewX(double aSx) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->SkewXSelf(aSx);
+
+  return retval.forget();
+}
+
+already_AddRefed<WebKitCSSMatrix> WebKitCSSMatrix::SkewY(double aSy) const {
+  RefPtr<WebKitCSSMatrix> retval = new WebKitCSSMatrix(mParent, *this);
+  retval->SkewYSelf(aSy);
+
+  return retval.forget();
+}
+
+}  // namespace dom
+}  // namespace mozilla
new file mode 100644
--- /dev/null
+++ b/dom/base/WebKitCSSMatrix.h
@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_dom_webkitcssmatrix_h__
+#define mozilla_dom_webkitcssmatrix_h__
+
+#include "mozilla/dom/DOMMatrix.h"
+
+namespace mozilla {
+namespace dom {
+
+class WebKitCSSMatrix final : public DOMMatrix {
+ public:
+  explicit WebKitCSSMatrix(nsISupports* aParent) : DOMMatrix(aParent) {}
+
+  WebKitCSSMatrix(nsISupports* aParent, const DOMMatrixReadOnly& other)
+      : DOMMatrix(aParent, other) {}
+
+  static bool FeatureEnabled(JSContext* aCx, JSObject* aObj);
+
+  static already_AddRefed<WebKitCSSMatrix> Constructor(
+      const GlobalObject& aGlobal, ErrorResult& aRv);
+  static already_AddRefed<WebKitCSSMatrix> Constructor(
+      const GlobalObject& aGlobal, const nsAString& aTransformList,
+      ErrorResult& aRv);
+  static already_AddRefed<WebKitCSSMatrix> Constructor(
+      const GlobalObject& aGlobal, const DOMMatrixReadOnly& aOther,
+      ErrorResult& aRv);
+
+  nsISupports* GetParentObject() const { return mParent; }
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  WebKitCSSMatrix* SetMatrixValue(const nsAString& aTransformList,
+                                  ErrorResult& aRv);
+
+  already_AddRefed<WebKitCSSMatrix> Multiply(const DOMMatrixInit& aOtherInit,
+                                             ErrorResult& aRv) const;
+  already_AddRefed<WebKitCSSMatrix> Inverse(ErrorResult& aRv) const;
+  already_AddRefed<WebKitCSSMatrix> Translate(double aTx, double aTy,
+                                              double aTz) const;
+  already_AddRefed<WebKitCSSMatrix> Rotate(double aRotX,
+                                           const Optional<double>& aRotY,
+                                           const Optional<double>& aRotZ) const;
+  already_AddRefed<WebKitCSSMatrix> RotateAxisAngle(double aX, double aY,
+                                                    double aZ,
+                                                    double aAngle) const;
+  already_AddRefed<WebKitCSSMatrix> SkewX(double aSx) const;
+  already_AddRefed<WebKitCSSMatrix> SkewY(double aSy) const;
+
+ protected:
+  WebKitCSSMatrix* Rotate3dSelf(double aRotX, double aRotY, double aRotZ);
+
+  WebKitCSSMatrix* InvertSelfThrow(ErrorResult& aRv);
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* mozilla_dom_webkitcssmatrix_h__ */
--- a/dom/base/moz.build
+++ b/dom/base/moz.build
@@ -240,16 +240,17 @@ EXPORTS.mozilla.dom += [
     'TimeoutHandler.h',
     'TimeoutManager.h',
     'TreeIterator.h',
     'TreeOrderedArray.h',
     'TreeOrderedArrayInlines.h',
     'TreeWalker.h',
     'UIDirectionManager.h',
     'VisualViewport.h',
+    'WebKitCSSMatrix.h',
     'WindowOrientationObserver.h',
     'WindowProxyHolder.h',
 ]
 
 if CONFIG['FUZZING']:
     EXPORTS.mozilla.dom += [
         'FuzzingFunctions.h',
     ]
@@ -410,16 +411,17 @@ UNIFIED_SOURCES += [
     'Timeout.cpp',
     'TimeoutBudgetManager.cpp',
     'TimeoutExecutor.cpp',
     'TimeoutHandler.cpp',
     'TimeoutManager.cpp',
     'TreeWalker.cpp',
     'UIDirectionManager.cpp',
     'VisualViewport.cpp',
+    'WebKitCSSMatrix.cpp',
     'WindowDestroyedEvent.cpp',
     'WindowNamedPropertiesHandler.cpp',
     'WindowOrientationObserver.cpp',
     'XPathGenerator.cpp',
 ]
 
 if CONFIG['MOZ_WEBRTC']:
     UNIFIED_SOURCES += [
--- a/dom/bindings/BindingUtils.cpp
+++ b/dom/bindings/BindingUtils.cpp
@@ -725,18 +725,17 @@ static bool DefineConstructor(JSContext*
 }
 
 static JSObject* CreateInterfaceObject(
     JSContext* cx, JS::Handle<JSObject*> global,
     JS::Handle<JSObject*> constructorProto, const js::Class* constructorClass,
     unsigned ctorNargs, const NamedConstructor* namedConstructors,
     JS::Handle<JSObject*> proto, const NativeProperties* properties,
     const NativeProperties* chromeOnlyProperties, const char* name,
-    bool isChrome, bool defineOnGlobal,
-    const char* const* legacyWindowAliases) {
+    bool isChrome, bool defineOnGlobal) {
   JS::Rooted<JSObject*> constructor(cx);
   MOZ_ASSERT(constructorProto);
   MOZ_ASSERT(constructorClass);
   constructor = JS_NewObjectWithGivenProto(cx, Jsvalify(constructorClass),
                                            constructorProto);
   if (!constructor) {
     return nullptr;
   }
@@ -816,24 +815,16 @@ static JSObject* CreateInterfaceObject(
   if (proto && !JS_LinkConstructorAndPrototype(cx, constructor, proto)) {
     return nullptr;
   }
 
   if (defineOnGlobal && !DefineConstructor(cx, global, name, constructor)) {
     return nullptr;
   }
 
-  if (legacyWindowAliases && NS_IsMainThread()) {
-    for (; *legacyWindowAliases; ++legacyWindowAliases) {
-      if (!DefineConstructor(cx, global, *legacyWindowAliases, constructor)) {
-        return nullptr;
-      }
-    }
-  }
-
   if (namedConstructors) {
     int namedConstructorSlot = DOM_INTERFACE_SLOTS_BASE;
     while (namedConstructors->mName) {
       JS::Rooted<JSObject*> namedConstructor(
           cx, CreateConstructor(cx, global, namedConstructors->mName,
                                 &namedConstructors->mHolder,
                                 namedConstructors->mNargs));
       if (!namedConstructor ||
@@ -954,18 +945,17 @@ bool DefineProperties(JSContext* cx, JS:
 void CreateInterfaceObjects(
     JSContext* cx, JS::Handle<JSObject*> global,
     JS::Handle<JSObject*> protoProto, const js::Class* protoClass,
     JS::Heap<JSObject*>* protoCache, const char* toStringTag,
     JS::Handle<JSObject*> constructorProto, const js::Class* constructorClass,
     unsigned ctorNargs, const NamedConstructor* namedConstructors,
     JS::Heap<JSObject*>* constructorCache, const NativeProperties* properties,
     const NativeProperties* chromeOnlyProperties, const char* name,
-    bool defineOnGlobal, const char* const* unscopableNames, bool isGlobal,
-    const char* const* legacyWindowAliases) {
+    bool defineOnGlobal, const char* const* unscopableNames, bool isGlobal) {
   MOZ_ASSERT(protoClass || constructorClass, "Need at least one class!");
   MOZ_ASSERT(
       !((properties &&
          (properties->HasMethods() || properties->HasAttributes())) ||
         (chromeOnlyProperties && (chromeOnlyProperties->HasMethods() ||
                                   chromeOnlyProperties->HasAttributes()))) ||
           protoClass,
       "Methods or properties but no protoClass!");
@@ -1007,17 +997,17 @@ void CreateInterfaceObjects(
     MOZ_ASSERT(!proto);
   }
 
   JSObject* interface;
   if (constructorClass) {
     interface = CreateInterfaceObject(
         cx, global, constructorProto, constructorClass, ctorNargs,
         namedConstructors, proto, properties, chromeOnlyProperties, name,
-        isChrome, defineOnGlobal, legacyWindowAliases);
+        isChrome, defineOnGlobal);
     if (!interface) {
       if (protoCache) {
         // If we fail we need to make sure to clear the value of protoCache we
         // set above.
         *protoCache = nullptr;
       }
       return;
     }
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -715,37 +715,33 @@ struct NamedConstructor {
  *                false in situations where we want the properties to only
  *                appear on privileged Xrays but not on the unprivileged
  *                underlying global.
  * unscopableNames if not null it points to a null-terminated list of const
  *                 char* names of the unscopable properties for this interface.
  * isGlobal if true, we're creating interface objects for a [Global] or
  *        [PrimaryGlobal] interface, and hence shouldn't define properties on
  *        the prototype object.
- * legacyWindowAliases if not null it points to a null-terminated list of const
- *                     char* names of the legacy window aliases for this
- *                     interface.
  *
  * At least one of protoClass, constructorClass or constructor should be
  * non-null. If constructorClass or constructor are non-null, the resulting
  * interface object will be defined on the given global with property name
  * |name|, which must also be non-null.
  */
 // clang-format on
 void CreateInterfaceObjects(
     JSContext* cx, JS::Handle<JSObject*> global,
     JS::Handle<JSObject*> protoProto, const js::Class* protoClass,
     JS::Heap<JSObject*>* protoCache, const char* toStringTag,
     JS::Handle<JSObject*> interfaceProto, const js::Class* constructorClass,
     unsigned ctorNargs, const NamedConstructor* namedConstructors,
     JS::Heap<JSObject*>* constructorCache,
     const NativeProperties* regularProperties,
     const NativeProperties* chromeOnlyProperties, const char* name,
-    bool defineOnGlobal, const char* const* unscopableNames, bool isGlobal,
-    const char* const* legacyWindowAliases);
+    bool defineOnGlobal, const char* const* unscopableNames, bool isGlobal);
 
 /**
  * Define the properties (regular and chrome-only) on obj.
  *
  * obj the object to instal the properties on. This should be the interface
  *     prototype object for regular interfaces and the instance object for
  *     interfaces marked with Global.
  * properties contains the methods, attributes and constants to be defined on
--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -3043,25 +3043,24 @@ class CGCollectJSONAttributesMethod(CGAb
 
 
 class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
     """
     Generate the CreateInterfaceObjects method for an interface descriptor.
 
     properties should be a PropertyArrays instance.
     """
-    def __init__(self, descriptor, properties, haveUnscopables, haveLegacyWindowAliases):
+    def __init__(self, descriptor, properties, haveUnscopables):
         args = [Argument('JSContext*', 'aCx'),
                 Argument('JS::Handle<JSObject*>', 'aGlobal'),
                 Argument('ProtoAndIfaceCache&', 'aProtoAndIfaceCache'),
                 Argument('bool', 'aDefineOnGlobal')]
         CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args)
         self.properties = properties
         self.haveUnscopables = haveUnscopables
-        self.haveLegacyWindowAliases = haveLegacyWindowAliases
 
     def definition_body(self):
         (protoGetter, protoHandleGetter) = InterfacePrototypeObjectProtoGetter(self.descriptor)
         if protoHandleGetter is None:
             parentProtoType = "Rooted"
             getParentProto = "aCx, " + protoGetter
         else:
             parentProtoType = "Handle"
@@ -3180,34 +3179,32 @@ class CGCreateInterfaceObjectsMethod(CGA
                                         ${protoClass}, protoCache,
                                         ${toStringTag},
                                         ${constructorProto}, ${interfaceClass}, ${constructArgs}, ${namedConstructors},
                                         interfaceCache,
                                         ${properties},
                                         ${chromeProperties},
                                         ${name}, aDefineOnGlobal,
                                         ${unscopableNames},
-                                        ${isGlobal},
-                                        ${legacyWindowAliases});
+                                        ${isGlobal});
             """,
             protoClass=protoClass,
             parentProto=parentProto,
             protoCache=protoCache,
             toStringTag=toStringTag,
             constructorProto=constructorProto,
             interfaceClass=interfaceClass,
             constructArgs=constructArgs,
             namedConstructors=namedConstructors,
             interfaceCache=interfaceCache,
             properties=properties,
             chromeProperties=chromeProperties,
             name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr",
             unscopableNames="unscopableNames" if self.haveUnscopables else "nullptr",
-            isGlobal=toStringBool(isGlobal),
-            legacyWindowAliases="legacyWindowAliases" if self.haveLegacyWindowAliases else "nullptr")
+            isGlobal=toStringBool(isGlobal))
 
         # If we fail after here, we must clear interface and prototype caches
         # using this code: intermediate failure must not expose the interface in
         # partially-constructed state.  Note that every case after here needs an
         # interface prototype object.
         failureCode = dedent(
             """
             *protoCache = nullptr;
@@ -13362,30 +13359,20 @@ class CGDescriptor(CGThing):
         if haveUnscopables:
             cgThings.append(
                 CGList([CGGeneric("static const char* const unscopableNames[] = {"),
                         CGIndenter(CGList([CGGeneric('"%s"' % name) for
                                            name in unscopableNames] +
                                           [CGGeneric("nullptr")], ",\n")),
                         CGGeneric("};\n")], "\n"))
 
-        legacyWindowAliases = descriptor.interface.legacyWindowAliases
-        haveLegacyWindowAliases = len(legacyWindowAliases) != 0
-        if haveLegacyWindowAliases:
-            cgThings.append(
-                CGList([CGGeneric("static const char* const legacyWindowAliases[] = {"),
-                        CGIndenter(CGList([CGGeneric('"%s"' % name) for
-                                           name in legacyWindowAliases] +
-                                          [CGGeneric("nullptr")], ",\n")),
-                        CGGeneric("};\n")], "\n"))
-
         # CGCreateInterfaceObjectsMethod needs to come after our
         # CGDOMJSClass and unscopables, if any.
         cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties,
-                                                       haveUnscopables, haveLegacyWindowAliases))
+                                                       haveUnscopables))
 
         # CGGetProtoObjectMethod and CGGetConstructorObjectMethod need
         # to come after CGCreateInterfaceObjectsMethod.
         if descriptor.interface.hasInterfacePrototypeObject():
             cgThings.append(CGGetProtoObjectHandleMethod(descriptor))
             if descriptor.interface.hasChildInterfaces():
                 cgThings.append(CGGetProtoObjectMethod(descriptor))
         if descriptor.interface.hasInterfaceObject():
@@ -14341,17 +14328,16 @@ class CGRegisterWorkletBindings(CGAbstra
         return CGList(lines, "\n").define()
 
 
 def getGlobalNames(config):
     names = []
     for desc in config.getDescriptors(registersGlobalNamesOnWindow=True):
         names.append((desc.name, desc))
         names.extend((n.identifier.name, desc) for n in desc.interface.namedConstructors)
-        names.extend((n, desc) for n in desc.interface.legacyWindowAliases)
     return names
 
 class CGGlobalNames(CGGeneric):
     def __init__(self, config):
         currentOffset = 0
         strings = []
         entries = []
         for name, desc in getGlobalNames(config):
--- a/dom/bindings/parser/WebIDL.py
+++ b/dom/bindings/parser/WebIDL.py
@@ -699,17 +699,16 @@ class IDLInterfaceOrNamespace(IDLObjectW
         self.members = []
         self.maplikeOrSetlikeOrIterable = None
         self._partialInterfaces = []
         self._extendedAttrDict = {}
         # namedConstructors needs deterministic ordering because bindings code
         # outputs the constructs in the order that namedConstructors enumerates
         # them.
         self.namedConstructors = list()
-        self.legacyWindowAliases = []
         self.implementedInterfaces = set()
         self._consequential = False
         self._isKnownNonPartial = False
         # self.interfacesBasedOnSelf is the set of interfaces that inherit from
         # self or have self as a consequential interface, including self itself.
         # Used for distinguishability checking.
         self.interfacesBasedOnSelf = set([self])
         # self.interfacesImplementingSelf is the set of interfaces that directly
@@ -770,26 +769,16 @@ class IDLInterfaceOrNamespace(IDLObjectW
 
         if not self._isKnownNonPartial:
             raise WebIDLError("Interface %s does not have a non-partial "
                               "declaration" % self.identifier.name,
                               [self.location])
 
         IDLExposureMixins.finish(self, scope)
 
-        if len(self.legacyWindowAliases) > 0:
-            if not self.hasInterfaceObject():
-                raise WebIDLError("Interface %s unexpectedly has [LegacyWindowAlias] "
-                                  "and [NoInterfaceObject] together" % self.identifier.name,
-                                  [self.location])
-            if not self.isExposedInWindow():
-                raise WebIDLError("Interface %s has [LegacyWindowAlias] "
-                                  "but not exposed in Window" % self.identifier.name,
-                                  [self.location])
-
         # Now go ahead and merge in our partial interfaces.
         for partial in self._partialInterfaces:
             partial.finish(scope)
             self.addExtendedAttributes(partial.propagatedExtendedAttrs)
             self.members.extend(partial.members)
 
         # Generate maplike/setlike interface members. Since generated members
         # need to be treated like regular interface members, do this before
@@ -1739,28 +1728,16 @@ class IDLInterface(IDLInterfaceOrNamespa
                         "[PrimaryGlobal] specified twice",
                         [attr.location,
                          self.parentScope.primaryGlobalAttr.location])
                 self.parentScope.primaryGlobalAttr = attr
                 self.parentScope.primaryGlobalName = self.identifier.name
                 self.parentScope.addIfaceGlobalNames(self.identifier.name,
                                                      [self.identifier.name])
                 self._isOnGlobalProtoChain = True
-            elif identifier == "LegacyWindowAlias":
-                if attr.hasValue():
-                    self.legacyWindowAliases = [attr.value()]
-                elif attr.hasArgs():
-                    self.legacyWindowAliases = attr.args()
-                else:
-                    raise WebIDLError("[%s] must either take an identifier "
-                                      "or take an identifier list" % identifier,
-                                      [attr.location])
-                for alias in self.legacyWindowAliases:
-                    unresolved = IDLUnresolvedIdentifier(attr.location, alias)
-                    IDLObjectWithIdentifier(attr.location, self.parentScope, unresolved)
             elif identifier == "SecureContext":
                 if not attr.noArguments():
                     raise WebIDLError("[%s] must take no arguments" % identifier,
                                       [attr.location])
                 # This gets propagated to all our members.
                 for member in self.members:
                     if member.getExtendedAttribute("SecureContext"):
                         raise WebIDLError("[SecureContext] specified on both "
--- a/dom/bindings/parser/tests/test_interface.py
+++ b/dom/bindings/parser/tests/test_interface.py
@@ -369,94 +369,8 @@ def WebIDLTest(parser, harness):
                 readonly attribute boolean y;
             };
         """)
         results = parser.finish()
     except:
         threw = True
     harness.ok(threw,
                "Should not allow unknown extended attributes on interfaces")
-
-    parser = parser.reset()
-    parser.parse("""
-        [Global] interface Window {};
-        [Exposed=Window, LegacyWindowAlias=A]
-        interface B {};
-        [Exposed=Window, LegacyWindowAlias=(C, D)]
-        interface E {};
-    """);
-    results = parser.finish();
-    harness.check(results[1].legacyWindowAliases, ["A"],
-                  "Should support a single identifier")
-    harness.check(results[2].legacyWindowAliases, ["C", "D"],
-                  "Should support an identifier list")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [LegacyWindowAlias]
-            interface A {};
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [LegacyWindowAlias] with no value")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [Exposed=Worker, LegacyWindowAlias=B]
-            interface A {};
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [LegacyWindowAlias] without Window exposure")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [Global] interface Window {};
-            interface A {};
-            [Exposed=Window, LegacyWindowAlias=A]
-            interface B {};
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [LegacyWindowAlias] to conflict with other identifiers")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [Global] interface Window {};
-            [Exposed=Window, LegacyWindowAlias=A]
-            interface B {};
-            interface A {};
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [LegacyWindowAlias] to conflict with other identifiers")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [Global] interface Window {};
-            [Exposed=Window, LegacyWindowAlias=A]
-            interface B {};
-            [Exposed=Window, LegacyWindowAlias=A]
-            interface C {};
-        """)
-        results = parser.finish()
-    except:
-        threw = True
-    harness.ok(threw,
-               "Should not allow [LegacyWindowAlias] to conflict with other identifiers")
--- a/dom/webidl/DOMMatrix.webidl
+++ b/dom/webidl/DOMMatrix.webidl
@@ -90,18 +90,17 @@ interface DOMMatrixReadOnly {
 [Pref="layout.css.DOMMatrix.enabled",
  Constructor,
  Constructor(DOMString transformList),
  Constructor(DOMMatrixReadOnly other),
  Constructor(Float32Array array32),
  Constructor(Float64Array array64),
  Constructor(sequence<unrestricted double> numberSequence),
  Exposed=(Window,Worker),
- Serializable,
- LegacyWindowAlias=WebKitCSSMatrix]
+ Serializable]
 interface DOMMatrix : DOMMatrixReadOnly {
     [NewObject, Throws] static DOMMatrix fromMatrix(optional DOMMatrixInit other = {});
     [NewObject, Throws] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32);
     [NewObject, Throws] static DOMMatrixReadOnly fromFloat64Array(Float64Array array64);
 
 
     // These attributes are simple aliases for certain elements of the 4x4 matrix
     inherit attribute unrestricted double a;
--- a/dom/webidl/URL.webidl
+++ b/dom/webidl/URL.webidl
@@ -7,18 +7,17 @@
  * http://url.spec.whatwg.org/#api
  * http://dev.w3.org/2006/webapi/FileAPI/#creating-revoking
  *
  * Copyright © 2012 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C
  * liability, trademark and document use rules apply.
  */
 
 [Constructor(USVString url, optional USVString base),
- Exposed=(Window,Worker,WorkerDebugger),
- LegacyWindowAlias=webkitURL]
+ Exposed=(Window,Worker,WorkerDebugger)]
 interface URL {
   // Bug 824857: no support for stringifier attributes yet.
   //  stringifier attribute USVString href;
 
   // Bug 824857 should remove this.
   stringifier;
 
   [SetterThrows]
new file mode 100644
--- /dev/null
+++ b/dom/webidl/WebKitCSSMatrix.webidl
@@ -0,0 +1,37 @@
+/* -*- 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/.
+ *
+ * The origin of this IDL file is
+ * https://compat.spec.whatwg.org/#webkitcssmatrix-interface
+ */
+
+[Constructor,
+ Constructor(DOMString transformList),
+ Constructor(WebKitCSSMatrix other),
+ Exposed=Window,
+ Func="mozilla::dom::WebKitCSSMatrix::FeatureEnabled"]
+interface WebKitCSSMatrix : DOMMatrix {
+    // Mutable transform methods
+    [Throws]
+    WebKitCSSMatrix setMatrixValue(DOMString transformList);
+
+    // Immutable transform methods
+    [Throws]
+    WebKitCSSMatrix multiply(optional DOMMatrixInit other);
+    [Throws]
+    WebKitCSSMatrix inverse();
+    WebKitCSSMatrix translate(optional unrestricted double tx = 0,
+                              optional unrestricted double ty = 0,
+                              optional unrestricted double tz = 0);
+    WebKitCSSMatrix rotate(optional unrestricted double rotX = 0,
+                           optional unrestricted double rotY,
+                           optional unrestricted double rotZ);
+    WebKitCSSMatrix rotateAxisAngle(optional unrestricted double x = 0,
+                                    optional unrestricted double y = 0,
+                                    optional unrestricted double z = 0,
+                                    optional unrestricted double angle = 0);
+    WebKitCSSMatrix skewX(optional unrestricted double sx = 0);
+    WebKitCSSMatrix skewY(optional unrestricted double sy = 0);
+};
--- a/dom/webidl/moz.build
+++ b/dom/webidl/moz.build
@@ -326,16 +326,19 @@ with Files("WebAuthentication.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Device Interfaces")
 
 with Files("WebGL*"):
     BUG_COMPONENT = ("Core", "Canvas: WebGL")
 
 with Files("WebGPU*"):
     BUG_COMPONENT = ("Core", "Canvas: WebGL")
 
+with Files("WebKitCSSMatrix.webidl"):
+    BUG_COMPONENT = ("Core", "DOM: CSS Object Model")
+
 with Files("Webrtc*"):
     BUG_COMPONENT = ("Core", "WebRTC")
 
 with Files("WheelEvent.webidl"):
     BUG_COMPONENT = ("Core", "DOM: Events")
 
 with Files("WidevineCDMManifest.webidl"):
     BUG_COMPONENT = ("Core", "Audio/Video: Playback")
@@ -927,16 +930,17 @@ WEBIDL_FILES = [
     'VTTRegion.webidl',
     'WaveShaperNode.webidl',
     'WebAuthentication.webidl',
     'WebComponents.webidl',
     'WebGL2RenderingContext.webidl',
     'WebGLRenderingContext.webidl',
     'WebGPU.webidl',
     'WebGPUExtras.webidl',
+    'WebKitCSSMatrix.webidl',
     'WebSocket.webidl',
     'WheelEvent.webidl',
     'WidevineCDMManifest.webidl',
     'WindowOrWorkerGlobalScope.webidl',
     'WindowRoot.webidl',
     'Worker.webidl',
     'WorkerDebuggerGlobalScope.webidl',
     'WorkerGlobalScope.webidl',
new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/css/geometry/WebKitCSSMatrix.html.ini
@@ -0,0 +1,4 @@
+[WebKitCSSMatrix.html]
+  [Equivalence test]
+    expected: FAIL
+
new file mode 100644
--- /dev/null
+++ b/testing/web-platform/meta/url/idlharness.any.js.ini
@@ -0,0 +1,6 @@
+[idlharness.any.html]
+  [URL interface: legacy window alias]
+    expected: FAIL
+
+
+[idlharness.any.worker.html]