Back out c70626e77e9f (bug 978235) on suspicion of mochitest-chrome assertions
authorPhil Ringnalda <philringnalda@gmail.com>
Mon, 14 Apr 2014 18:35:46 -0700
changeset 196930 f75f603b27e4267961067d486ede4b831887f32a
parent 196929 81dd41a77b43be1bac65203c9021d199fe1739dc
child 196931 351382fc8e1fc7507332225afe34baa11dfa45ce
push id3624
push userasasaki@mozilla.com
push dateMon, 09 Jun 2014 21:49:01 +0000
treeherdermozilla-beta@b1a5da15899a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs978235
milestone31.0a1
backs outc70626e77e9fe193ffab0c2a9b94b21e1dae1174
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
Back out c70626e77e9f (bug 978235) on suspicion of mochitest-chrome assertions CLOSED TREE
js/src/js.msg
js/src/jsproxy.cpp
js/src/tests/ecma_6/Proxy/proxy-isExtensible.js
js/src/vm/CommonPropertyNames.h
--- a/js/src/js.msg
+++ b/js/src/js.msg
@@ -432,9 +432,8 @@ MSG_DEF(JSMSG_RC_AFTER_EXPORT_SPEC_LIST,
 MSG_DEF(JSMSG_NO_EXPORT_NAME,           378, 0, JSEXN_SYNTAXERR, "missing export name")
 MSG_DEF(JSMSG_DECLARATION_AFTER_EXPORT, 379, 0, JSEXN_SYNTAXERR, "missing declaration after 'export' keyword")
 MSG_DEF(JSMSG_INVALID_PROTOTYPE,        380, 0, JSEXN_TYPEERR, "prototype field is not an object")
 MSG_DEF(JSMSG_TYPEDOBJECT_HANDLE_TO_UNSIZED, 381, 0, JSEXN_TYPEERR, "cannot create a handle to an unsized type")
 MSG_DEF(JSMSG_SETPROTOTYPEOF_FAIL,      382, 1, JSEXN_TYPEERR, "[[SetPrototypeOf]] failed on {0}")
 MSG_DEF(JSMSG_INVALID_ARG_TYPE,         383, 3, JSEXN_TYPEERR, "Invalid type: {0} can't be a{1} {2}")
 MSG_DEF(JSMSG_TERMINATED,               384, 1, JSEXN_ERR, "Script terminated by timeout at:\n{0}")
 MSG_DEF(JSMSG_NO_SUCH_SELF_HOSTED_PROP, 385, 1, JSEXN_ERR, "No such property on self-hosted object: {0}")
-MSG_DEF(JSMSG_PROXY_EXTENSIBILITY,      386, 0, JSEXN_TYPEERR, "proxy must report same extensiblitity as target")
--- a/js/src/jsproxy.cpp
+++ b/js/src/jsproxy.cpp
@@ -1072,16 +1072,22 @@ ScriptedIndirectProxyHandler::fun_toStri
         return nullptr;
     }
     RootedObject obj(cx, &proxy->as<ProxyObject>().extra(0).toObject().getReservedSlot(0).toObject());
     return fun_toStringHelper(cx, obj, indent);
 }
 
 ScriptedIndirectProxyHandler ScriptedIndirectProxyHandler::singleton;
 
+static JSObject *
+GetDirectProxyHandlerObject(JSObject *proxy)
+{
+    return proxy->as<ProxyObject>().extra(0).toObjectOrNull();
+}
+
 /* Derived class for all scripted direct proxy handlers. */
 class ScriptedDirectProxyHandler : public DirectProxyHandler {
   public:
     ScriptedDirectProxyHandler();
     virtual ~ScriptedDirectProxyHandler();
 
     /* ES5 Harmony fundamental proxy traps. */
     virtual bool preventExtensions(JSContext *cx, HandleObject proxy) MOZ_OVERRIDE;
@@ -1103,19 +1109,16 @@ class ScriptedDirectProxyHandler : publi
     virtual bool get(JSContext *cx, HandleObject proxy, HandleObject receiver, HandleId id,
                      MutableHandleValue vp) MOZ_OVERRIDE;
     virtual bool set(JSContext *cx, HandleObject proxy, HandleObject receiver, HandleId id,
                      bool strict, MutableHandleValue vp) MOZ_OVERRIDE;
     virtual bool keys(JSContext *cx, HandleObject proxy, AutoIdVector &props) MOZ_OVERRIDE;
     virtual bool iterate(JSContext *cx, HandleObject proxy, unsigned flags,
                          MutableHandleValue vp) MOZ_OVERRIDE;
 
-    /* ES6 Harmony traps */
-    virtual bool isExtensible(JSContext *cx, HandleObject proxy, bool *extensible) MOZ_OVERRIDE;
-
     /* Spidermonkey extensions. */
     virtual bool call(JSContext *cx, HandleObject proxy, const CallArgs &args) MOZ_OVERRIDE;
     virtual bool construct(JSContext *cx, HandleObject proxy, const CallArgs &args) MOZ_OVERRIDE;
     virtual bool isScripted() MOZ_OVERRIDE { return true; }
 
     static ScriptedDirectProxyHandler singleton;
 };
 
@@ -1357,26 +1360,16 @@ IdToValue(JSContext *cx, HandleId id, Mu
     value.set(IdToValue(id)); // Re-use out-param to avoid Rooted overhead.
     JSString *name = ToString<CanGC>(cx, value);
     if (!name)
         return false;
     value.set(StringValue(name));
     return true;
 }
 
-// Get the [[ProxyHandler]] of a scripted direct proxy.
-//
-// NB: This *must* stay synched with proxy().
-static JSObject *
-GetDirectProxyHandlerObject(JSObject *proxy)
-{
-    JS_ASSERT(proxy->as<ProxyObject>().handler() == &ScriptedDirectProxyHandler::singleton);
-    return proxy->as<ProxyObject>().extra(0).toObjectOrNull();
-}
-
 // TrapGetOwnProperty(O, P)
 static bool
 TrapGetOwnProperty(JSContext *cx, HandleObject proxy, HandleId id, MutableHandleValue rval)
 {
     // step 1
     RootedObject handler(cx, GetDirectProxyHandlerObject(proxy));
 
     // step 2
@@ -2227,52 +2220,16 @@ ScriptedDirectProxyHandler::keys(JSConte
                              v, js::NullPtr(), bytes.ptr());
         return false;
     }
 
     // steps g-n are shared
     return ArrayToIdVector(cx, proxy, target, trapResult, props, JSITER_OWNONLY, cx->names().keys);
 }
 
-// ES6 (5 April, 2014) 9.5.3 Proxy.[[IsExtensible]](P)
-bool
-ScriptedDirectProxyHandler::isExtensible(JSContext *cx, HandleObject proxy, bool *extensible)
-{
-    RootedObject handler(cx, GetDirectProxyHandlerObject(proxy));
-
-    RootedObject target(cx, proxy->as<ProxyObject>().target());
-
-    RootedValue trap(cx);
-    if (!JSObject::getProperty(cx, handler, handler, cx->names().isExtensible, &trap))
-        return false;
-
-    if (trap.isUndefined())
-        return DirectProxyHandler::isExtensible(cx, proxy, extensible);
-
-    Value argv[] = {
-        ObjectValue(*target)
-    };
-    RootedValue trapResult(cx);
-    if (!Invoke(cx, ObjectValue(*handler), trap, ArrayLength(argv), argv, &trapResult))
-        return false;
-
-    bool booleanTrapResult = ToBoolean(trapResult);
-    bool targetResult;
-    if (!JSObject::isExtensible(cx, target, &targetResult))
-        return false;
-
-    if (targetResult != booleanTrapResult) {
-       JS_ReportErrorNumber(cx, js_GetErrorMessage, nullptr, JSMSG_PROXY_EXTENSIBILITY);
-       return false;
-    }
-
-    *extensible = booleanTrapResult;
-    return true;
-}
-
 bool
 ScriptedDirectProxyHandler::iterate(JSContext *cx, HandleObject proxy, unsigned flags,
                                     MutableHandleValue vp)
 {
     // FIXME: Provide a proper implementation for this trap, see bug 787004
     return DirectProxyHandler::iterate(cx, proxy, flags, vp);
 }
 
deleted file mode 100644
--- a/js/src/tests/ecma_6/Proxy/proxy-isExtensible.js
+++ /dev/null
@@ -1,94 +0,0 @@
-// Test ES6 Proxy trap compliance for Object.isExtensible() on exotic proxy
-// objects.
-var unsealed = {};
-var sealed = Object.seal({});
-var handler = {};
-
-assertEq(Object.isExtensible(unsealed), true);
-assertEq(Object.isExtensible(sealed), false);
-
-var targetSealed = new Proxy(sealed, handler);
-var targetUnsealed = new Proxy(unsealed, handler);
-
-var handlerCalled = false;
-
-// without traps, forward to the target
-// First, make sure we get the obvious answer on a non-exotic target.
-assertEq(Object.isExtensible(targetSealed), false, "Must forward to target without hook.");
-assertEq(Object.isExtensible(targetUnsealed), true, "Must forward to target without hook.");
-
-// Now, keep everyone honest. What if the target itself is a proxy?
-function ensureCalled() { handlerCalled = true; return true; }
-var proxyTarget = new Proxy({}, { isExtensible : ensureCalled });
-assertEq(Object.isExtensible(new Proxy(proxyTarget, {})), true, "Must forward to target without hook.");
-assertEq(handlerCalled, true, "Must forward to target without hook.");
-
-// with traps, makes sure that the handler is called, and that we throw if the
-// trap disagrees with the target
-function testExtensible(obj, shouldThrow, expectedResult)
-{
-    handlerCalled = false;
-    if (shouldThrow)
-        assertThrowsInstanceOf(function () { Object.isExtensible(obj); },
-                               TypeError, "Must throw if handler and target disagree.");
-    else
-        assertEq(Object.isExtensible(obj), expectedResult, "Must return the correct value.");
-    assertEq(handlerCalled, true, "Must call handler trap if present");
-}
-
-// What if the trap says it's necessarily sealed?
-function fakeSealed() { handlerCalled = true; return false; }
-handler.isExtensible = fakeSealed;
-testExtensible(targetSealed, false, false);
-testExtensible(targetUnsealed, true);
-
-// What if the trap says it's never sealed?
-function fakeUnsealed() { handlerCalled = true; return true; }
-handler.isExtensible = fakeUnsealed;
-testExtensible(targetSealed, true);
-testExtensible(targetUnsealed, false, true);
-
-// make sure we are able to prevent further extensions mid-flight and throw if the
-// hook tries to lie.
-function makeSealedTruth(target) { handlerCalled = true; Object.preventExtensions(target); return false; }
-function makeSealedLie(target) { handlerCalled = true; Object.preventExtensions(target); return true; }
-handler.isExtensible = makeSealedTruth;
-testExtensible(new Proxy({}, handler), false, false);
-handler.isExtensible = makeSealedLie;
-testExtensible(new Proxy({}, handler), true);
-
-// What if the trap doesn't directly return a boolean?
-function falseyNonBool() { handlerCalled = true; return undefined; }
-handler.isExtensible = falseyNonBool;
-testExtensible(targetSealed, false, false);
-testExtensible(targetUnsealed, true);
-
-function truthyNonBool() { handlerCalled = true; return {}; }
-handler.isExtensible = truthyNonBool;
-testExtensible(targetSealed, true);
-testExtensible(targetUnsealed, false, true);
-
-// What if the trap throws?
-function ExtensibleError() { }
-ExtensibleError.prototype = new Error();
-ExtensibleError.prototype.constructor = ExtensibleError;
-function throwFromTrap() { throw new ExtensibleError(); }
-handler.isExtensible = throwFromTrap;
-
-// exercise some other code paths and make sure that they invoke the trap and
-// can handle the ensuing error.
-assertThrowsInstanceOf(function () { Object.isExtensible(targetSealed); },
-                       ExtensibleError, "Must throw if the trap does.");
-assertThrowsInstanceOf(function () { Object.isFrozen(targetSealed); },
-                       ExtensibleError, "Must throw if the trap does.");
-assertThrowsInstanceOf(function () { Object.isSealed(targetSealed); },
-                       ExtensibleError, "Must throw if the trap does.");
-
-
-// What if the trap likes to re-ask old questions?
-function recurse() { return Object.isExtensible(targetSealed); }
-handler.isExtensible = recurse;
-assertThrowsInstanceOf(function () { Object.isExtensible(targetSealed); },
-                       InternalError, "Should allow and detect infinite recurison.");
-
-reportCompare(0, 0, "OK");
--- a/js/src/vm/CommonPropertyNames.h
+++ b/js/src/vm/CommonPropertyNames.h
@@ -98,17 +98,16 @@
     macro(isFinite, isFinite, "isFinite") \
     macro(isNaN, isNaN, "isNaN") \
     macro(isPrototypeOf, isPrototypeOf, "isPrototypeOf") \
     macro(iterate, iterate, "iterate") \
     macro(Infinity, Infinity, "Infinity") \
     macro(int8, int8, "int8") \
     macro(int16, int16, "int16") \
     macro(int32, int32, "int32") \
-    macro(isExtensible, isExtensible, "isExtensible") \
     macro(iterator, iterator, "iterator") \
     macro(iteratorIntrinsic, iteratorIntrinsic, "__iterator__") \
     macro(join, join, "join") \
     macro(keys, keys, "keys") \
     macro(lastIndex, lastIndex, "lastIndex") \
     macro(length, length, "length") \
     macro(let, let, "let") \
     macro(line, line, "line") \