Backed out 5 changesets (bug 1507950, bug 1503012, bug 1507943, bug 1512050, bug 1512008) for spidermonkey and jit failures

Backed out changeset 71253f35ac3c (bug 1512008)
Backed out changeset f5c4eb412990 (bug 1512050)
Backed out changeset bc83a2fe5c17 (bug 1507950)
Backed out changeset 345ad3e746e8 (bug 1507943)
Backed out changeset b2a0ae5e5115 (bug 1503012)

Author: dgluca

build/gen_test_packages_manifest.py

@@ -76,12 +76,9 @@ def generate_package_data(args):
     # specific zips.
     tests_common = args.tests_common
     jsshell = args.jsshell
-    web_platform = getattr(args, 'web-platform')
 
     harness_requirements = dict([(k, [tests_common]) for k in ALL_HARNESSES])
     harness_requirements['jittest'].append(jsshell)
-    harness_requirements['jittest'].append(web_platform)
-
     for harness in PACKAGE_SPECIFIED_HARNESSES + OPTIONAL_PACKAGES:
         pkg_name = getattr(args, harness, None)
         if pkg_name is None:

js/src/builtin/Promise.cpp

@@ -3344,16 +3344,8 @@ MOZ_MUST_USE bool js::OriginalPromiseThen(
     JSContext* cx, HandleObject promiseObj, HandleValue onFulfilled,
     HandleValue onRejected, MutableHandleObject dependent,
     CreateDependentPromise createDependent) {
-  RootedValue promiseVal(cx, ObjectValue(*promiseObj));
   Rooted<PromiseObject*> promise(
-      cx, UnwrapAndTypeCheckValue<PromiseObject>(cx, promiseVal, [=] {
-        JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr,
-                                   JSMSG_INCOMPATIBLE_PROTO, "Promise", "then",
-                                   promiseObj->getClass()->name);
-      }));
-  if (!promise) {
-    return false;
-  }
+      cx, &CheckedUnwrap(promiseObj)->as<PromiseObject>());
 
   // Steps 3-4.
   Rooted<PromiseCapability> resultCapability(cx);

js/src/builtin/Stream.cpp

@@ -242,34 +242,19 @@ class ReadableStreamController : public StreamController {
    * Memory layout for ReadableStream controllers, starting after the slots
    * reserved for queue container usage.
    *
-   * Storage of the internal slots listed in the standard is fairly
-   * straightforward except for [[pullAlgorithm]] and [[cancelAlgorithm]].
-   * These algorithms are not stored as JSFunction objects. Rather, there are
-   * three cases:
+   * UnderlyingSource is usually treated as an opaque value. It might be a
+   * wrapped object from another compartment, but that case is handled
+   * correctly by all operations the controller might invoke on it.
    *
-   * -   Streams created with `new ReadableStream`: The methods are stored
-   *     in Slot_PullMethod and Slot_CancelMethod. The underlying source
-   *     object (`this` for these methods) is in Slot_UnderlyingSource.
-   *
-   * -   External source streams. Slot_UnderlyingSource is a PrivateValue
-   *     pointing to the JS::ReadableStreamUnderlyingSource object. The
-   *     algorithms are implemented using the .pull() and .cancel() methods
-   *     of that object. Slot_Pull/CancelMethod are undefined.
-   *
-   * -   Tee streams. Slot_UnderlyingSource is a TeeState object. The
-   *     pull/cancel algorithms are implemented as separate functions in
-   *     Stream.cpp. Slot_Pull/CancelMethod are undefined.
-   *
-   * UnderlyingSource, PullMethod, and CancelMethod can be wrappers to objects
-   * in other compartments.
+   * The only case where we don't treat underlyingSource as an opaque value is
+   * if it's a TeeState. All functions operating on TeeState properly handle
+   * TeeState instances from other compartments.
    *
    * StrategyHWM and Flags are both primitive (numeric) values.
    */
   enum Slots {
     Slot_Stream = StreamController::SlotCount,
     Slot_UnderlyingSource,
-    Slot_PullMethod,
-    Slot_CancelMethod,
     Slot_StrategyHWM,
     Slot_Flags,
     SlotCount
@@ -296,14 +281,6 @@ class ReadableStreamController : public StreamController {
   void setUnderlyingSource(const Value& underlyingSource) {
     setFixedSlot(Slot_UnderlyingSource, underlyingSource);
   }
-  Value pullMethod() const { return getFixedSlot(Slot_PullMethod); }
-  void setPullMethod(const Value& pullMethod) {
-    setFixedSlot(Slot_PullMethod, pullMethod);
-  }
-  Value cancelMethod() const { return getFixedSlot(Slot_CancelMethod); }
-  void setCancelMethod(const Value& cancelMethod) {
-    setFixedSlot(Slot_CancelMethod, cancelMethod);
-  }
   JS::ReadableStreamUnderlyingSource* externalSource() const {
     static_assert(alignof(JS::ReadableStreamUnderlyingSource) >= 2,
                   "External underling sources are stored as PrivateValues, "