keithamus
diff --git a/‎LayoutTests/TestExpectations
+3 b/‎LayoutTests/TestExpectations
+3
diff --git a/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any-expected.txt
+6-1 b/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any-expected.txt
+6-1
diff --git a/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any.js
+168-10 b/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any.js
+168-10
diff --git a/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any.worker-expected.txt
+5-1 b/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-constructor.any.worker-expected.txt
+5-1
diff --git a/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-drop.any-expected.txt
+9 b/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-drop.any-expected.txt
+9
diff --git a/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-drop.any.html
+1 b/‎LayoutTests/imported/w3c/web-platform-tests/dom/observable/tentative/observable-drop.any.html
+1
@@ -7887,3 +7887,6 @@ imported/w3c/web-platform-tests/css/css-viewport/zoom/word-spacing.html [ ImageO
 
 # WebRTC Encoded Transform - Test Expectation - Crashes on 'mac-wk2' debug and gtk-wk2 / wpe-wk2
 webkit.org/b/275663 imported/w3c/web-platform-tests/webrtc-encoded-transform/script-transform-generateKeyFrame-simulcast.https.html [ Skip ]
+
+# https://bugs.webkit.org/show_bug.cgi?id=266843 flakey tests with racey promise console.logs
+imported/w3c/web-platform-tests/dom/observable/tentative/observable-from.any.html [ Skip ]
@@ -8,6 +8,7 @@ CONSOLE MESSAGE: not a real error
 CONSOLE MESSAGE: not a real error
 CONSOLE MESSAGE: not a real error
 CONSOLE MESSAGE: Error: assert_false: expected false got true
+CONSOLE MESSAGE: calling error()
 CONSOLE MESSAGE: Error: custom error
 CONSOLE MESSAGE: Error: custom error
 
@@ -38,7 +39,11 @@ PASS Errors thrown by initializer function after subscriber is closed by error a
 PASS Errors pushed by initializer function after subscriber is closed by error are reported
 PASS Subscriber#complete() cannot re-entrantly invoke itself
 PASS Subscriber#error() cannot re-entrantly invoke itself
-FAIL Unsubscription lifecycle assert_array_equals: expected property 1 to be "outer abort handler" but got "inner abort handler" (expected array ["subscribe() callback", "outer abort handler", "teardown 2", "teardown 1", "inner abort handler", "abort() returned"] got ["subscribe() callback", "inner abort handler", "teardown 2", "teardown 1", "outer abort handler", "abort() returned"])
+PASS Unsubscription lifecycle
+PASS Teardowns are called in upstream->downstream order on consumer-initiated unsubscription
+PASS Teardowns are called in downstream->upstream order on consumer-initiated unsubscription with pre-aborted Signal
+PASS Producer-initiated unsubscription in a downstream Observable fires abort events before each teardown, in downstream->upstream order
+FAIL Subscriber#error() value is stored as Subscriber's AbortSignal's reason assert_equals: Reason is set correctly expected (string) "calling error()" but got (object) object "AbortError: The operation was aborted."
 PASS Aborting a subscription should stop emitting values
 PASS Calling subscribe should never throw an error synchronously, initializer throws error
 PASS Calling subscribe should never throw an error synchronously, subscriber pushes error
 
@@ -235,14 +235,18 @@ test(t => {
 
   source.subscribe({
     complete: () => {
-      activeDuringComplete = innerSubscriber.active
-      abortedDuringComplete = innerSubscriber.active
+      activeDuringComplete = innerSubscriber.active;
+      abortedDuringComplete = innerSubscriber.signal.aborted;
     }
   });
   assert_true(activeBeforeComplete, "Subscription is active before complete");
   assert_false(abortedBeforeComplete, "Subscription is not aborted before complete");
-  assert_false(activeDuringComplete, "Subscription is not active during complete");
-  assert_false(abortedDuringComplete, "Subscription is not aborted during complete");
+  assert_false(activeDuringComplete,
+      "Subscription becomes inactive during Subscriber#complete(), just " +
+      "before Observer#complete() callback is invoked");
+  assert_true(abortedDuringComplete,
+      "Subscription's signal is aborted during Subscriber#complete(), just " +
+      "before Observer#complete() callback is invoked");
   assert_false(activeAfterComplete, "Subscription is not active after complete");
   assert_true(abortedAfterComplete, "Subscription is aborted after complete");
 }, "Subscription is inactive after complete()");
@@ -269,13 +273,18 @@ test(t => {
 
   source.subscribe({
     error: () => {
-      activeDuringError = innerSubscriber.active
+      activeDuringError = innerSubscriber.active;
+      abortedDuringError = innerSubscriber.signal.aborted;
     }
   });
   assert_true(activeBeforeError, "Subscription is active before error");
   assert_false(abortedBeforeError, "Subscription is not aborted before error");
-  assert_false(activeDuringError, "Subscription is not active during error");
-  assert_false(abortedDuringError, "Subscription is not aborted during error");
+  assert_false(activeDuringError,
+      "Subscription becomes inactive during Subscriber#error(), just " +
+      "before Observer#error() callback is invoked");
+  assert_true(abortedDuringError,
+      "Subscription's signal is aborted during Subscriber#error(), just " +
+      "before Observer#error() callback is invoked");
   assert_false(activeAfterError, "Subscription is not active after error");
   assert_true(abortedAfterError, "Subscription is not aborted after error");
 }, "Subscription is inactive after error()");
@@ -679,17 +688,166 @@ test(() => {
   assert_array_equals(results, ['subscribe() callback']);
   ac.abort();
   results.push('abort() returned');
+  // The reason the "inner" abort event handler is invoked first is because the
+  // "inner" AbortSignal is not a dependent signal (that would ordinarily get
+  // aborted after the parent, aka "outer" signal, is completely finished being
+  // aborted). Instead, the order of operations looks like this:
+  //   1. "Outer" signal begins to be aborted
+  //   2. Its abort algorithms [1] run [2]; the internal abort algorithm here is
+  //      the "inner" Subscriber's "Close a subscription" [0].
+  //      a. This signals abort on the "inner" Subscriber's signal, firing the
+  //         abort event
+  //      b. Then, the "inner" Subscriber's teardowns run.
+  //   3. Once the "outer" signal's abort algorithms are finished, the abort
+  //      event is fired [3], triggering the outer abort handler.
+  //
+  // [0]: https://wicg.github.io/observable/#close-a-subscription
+  // [1]: https://dom.spec.whatwg.org/#abortsignal-abort-algorithms
+  // [2]: https://dom.spec.whatwg.org/#ref-for-abortsignal-abort-algorithms%E2%91%A2:~:text=For%20each%20algorithm%20of%20signal%E2%80%99s%20abort%20algorithms%3A%20run%20algorithm
+  // [3]: https://dom.spec.whatwg.org/#abortsignal-signal-abort:~:text=Fire%20an%20event%20named%20abort%20at%20signal
   assert_array_equals(results, [
-      'subscribe() callback',
-      'outer abort handler', 'teardown 2', 'teardown 1',
-      'inner abort handler', 'abort() returned',
+      'subscribe() callback', 'inner abort handler', 'teardown 2', 'teardown 1',
+      'outer abort handler', 'abort() returned',
   ]);
   assert_false(activeDuringTeardown1, 'should not be active during teardown callback 1');
   assert_false(activeDuringTeardown2, 'should not be active during teardown callback 2');
   assert_true(abortedDuringTeardown1, 'should be aborted during teardown callback 1');
   assert_true(abortedDuringTeardown2, 'should be aborted during teardown callback 2');
 }, "Unsubscription lifecycle");
 
+// In the usual consumer-initiated unsubscription case, when the AbortController
+// is aborted after subscription, teardowns run from upstream->downstream. This
+// is because for a given Subscriber, when a downstream signal is aborted
+// (`ac.signal` in this case), the "Close" algorithm prompts the Subscriber to
+// first abort *its* own signal (the one accessible via `Subscriber#signal`) and
+// then run its teardowns.
+//
+// This means upstream Subscribers get the first opportunity their teardowns
+// before the control flow is returned to downstream Subscribers to run *their*
+// teardowns (after they abort their internal signal).
+test(() => {
+  const results = [];
+  const upstream = new Observable(subscriber => {
+    subscriber.signal.addEventListener('abort',
+        e => results.push('upstream abort handler'), {once: true});
+    subscriber.addTeardown(
+        () => results.push(`upstream teardown. reason: ${subscriber.signal.reason}`));
+  });
+  const middle = new Observable(subscriber => {
+    subscriber.signal.addEventListener('abort',
+        e => results.push('middle abort handler'), {once: true});
+    subscriber.addTeardown(
+        () => results.push(`middle teardown. reason: ${subscriber.signal.reason}`));
+    upstream.subscribe({}, {signal: subscriber.signal});
+  });
+  const downstream = new Observable(subscriber => {
+    subscriber.signal.addEventListener('abort',
+        e => results.push('downstream abort handler'), {once: true});
+    subscriber.addTeardown(
+        () => results.push(`downstream teardown. reason: ${subscriber.signal.reason}`));
+    middle.subscribe({}, {signal: subscriber.signal});
+  });
+
+  const ac = new AbortController();
+  downstream.subscribe({}, {signal: ac.signal});
+  ac.abort('Abort!');
+  assert_array_equals(results, [
+      'upstream abort handler',
+      'upstream teardown. reason: Abort!',
+      'middle abort handler',
+      'middle teardown. reason: Abort!',
+      'downstream abort handler',
+      'downstream teardown. reason: Abort!',
+  ]);
+}, "Teardowns are called in upstream->downstream order on " +
+   "consumer-initiated unsubscription");
+
+// This test is like the above, but asserts the exact opposite order of
+// teardowns. This is because, since the Subscriber's signal is aborted
+// immediately upon construction, `addTeardown()` runs teardowns synchronously
+// in subscriber-order, which goes from downstream->upstream.
+test(() => {
+  const results = [];
+  const upstream = new Observable(subscriber => {
+    subscriber.addTeardown(
+        () => results.push(`upstream teardown. reason: ${subscriber.signal.reason}`));
+  });
+  const middle = new Observable(subscriber => {
+    subscriber.addTeardown(
+        () => results.push(`middle teardown. reason: ${subscriber.signal.reason}`));
+    upstream.subscribe({}, {signal: subscriber.signal});
+  });
+  const downstream = new Observable(subscriber => {
+    subscriber.addTeardown(
+        () => results.push(`downstream teardown. reason: ${subscriber.signal.reason}`));
+    middle.subscribe({}, {signal: subscriber.signal});
+  });
+
+  downstream.subscribe({}, {signal: AbortSignal.abort('Initial abort')});
+  assert_array_equals(results, [
+      "downstream teardown. reason: Initial abort",
+      "middle teardown. reason: Initial abort",
+      "upstream teardown. reason: Initial abort",
+  ]);
+}, "Teardowns are called in downstream->upstream order on " +
+   "consumer-initiated unsubscription with pre-aborted Signal");
+
+// Producer-initiated unsubscription test, capturing the ordering of abort events and teardowns.
+test(() => {
+  const results = [];
+
+  const source = new Observable(subscriber => {
+    subscriber.addTeardown(() => results.push('source teardown'));
+    subscriber.signal.addEventListener('abort',
+        e => results.push('source abort event'));
+  });
+
+  const middle = new Observable(subscriber => {
+    subscriber.addTeardown(() => results.push('middle teardown'));
+    subscriber.signal.addEventListener('abort',
+        e => results.push('middle abort event'));
+
+    source.subscribe(() => {}, {signal: subscriber.signal});
+  });
+
+  let innerSubscriber = null;
+  const downstream = new Observable(subscriber => {
+    innerSubscriber = subscriber;
+    subscriber.addTeardown(() => results.push('downstream teardown'));
+    subscriber.signal.addEventListener('abort',
+        e => results.push('downstream abort event'));
+
+    middle.subscribe(() => {}, {signal: subscriber.signal});
+  });
+
+  downstream.subscribe();
+
+  // Trigger a producer-initiated unsubscription from the most-downstream Observable.
+  innerSubscriber.complete();
+
+  assert_array_equals(results, [
+    'source abort event',
+    'source teardown',
+    'middle abort event',
+    'middle teardown',
+    'downstream abort event',
+    'downstream teardown',
+  ]);
+}, "Producer-initiated unsubscription in a downstream Observable fires abort " +
+   "events before each teardown, in downstream->upstream order");
+
+test(t => {
+  let innerSubscriber = null;
+  const source = new Observable(subscriber => {
+    innerSubscriber = subscriber;
+    subscriber.error('calling error()');
+  });
+
+  source.subscribe();
+  assert_equals(innerSubscriber.signal.reason, "calling error()",
+      "Reason is set correctly");
+}, "Subscriber#error() value is stored as Subscriber's AbortSignal's reason");
+
 test(t => {
   const source = new Observable((subscriber) => {
     let n = 0;
 
@@ -26,7 +26,11 @@ PASS Errors thrown by initializer function after subscriber is closed by error a
 PASS Errors pushed by initializer function after subscriber is closed by error are reported
 PASS Subscriber#complete() cannot re-entrantly invoke itself
 PASS Subscriber#error() cannot re-entrantly invoke itself
-FAIL Unsubscription lifecycle assert_array_equals: expected property 1 to be "outer abort handler" but got "inner abort handler" (expected array ["subscribe() callback", "outer abort handler", "teardown 2", "teardown 1", "inner abort handler", "abort() returned"] got ["subscribe() callback", "inner abort handler", "teardown 2", "teardown 1", "outer abort handler", "abort() returned"])
+PASS Unsubscription lifecycle
+PASS Teardowns are called in upstream->downstream order on consumer-initiated unsubscription
+PASS Teardowns are called in downstream->upstream order on consumer-initiated unsubscription with pre-aborted Signal
+PASS Producer-initiated unsubscription in a downstream Observable fires abort events before each teardown, in downstream->upstream order
+FAIL Subscriber#error() value is stored as Subscriber's AbortSignal's reason assert_equals: Reason is set correctly expected (string) "calling error()" but got (object) object "AbortError: The operation was aborted."
 PASS Aborting a subscription should stop emitting values
 PASS Calling subscribe should never throw an error synchronously, initializer throws error
 PASS Calling subscribe should never throw an error synchronously, subscriber pushes error
 
@@ -0,0 +1,9 @@
+
+FAIL drop(): Observable should skip the first n values from the source observable, then pass through the rest of the values and completion source.drop is not a function. (In 'source.drop(2)', 'source.drop' is undefined)
+FAIL drop(): Observable passes through errors from source Observable source.drop is not a function. (In 'source.drop(2)', 'source.drop' is undefined)
+FAIL drop(): Observable passes through errors from source observable even before drop count is met source.drop is not a function. (In 'source.drop(2)', 'source.drop' is undefined)
+FAIL drop(): Observable passes through completions from source observable even before drop count is met source.drop is not a function. (In 'source.drop(2)', 'source.drop' is undefined)
+FAIL drop(): Unsubscribing from the Observable returned by drop() also unsubscribes from the source Observable source.drop is not a function. (In 'source.drop(2)', 'source.drop' is undefined)
+FAIL drop(): A drop amount of 0 simply mirrors the source Observable source.drop is not a function. (In 'source.drop(0)', 'source.drop' is undefined)
+FAIL drop(): Passing negative value wraps to maximum value  source.drop is not a function. (In 'source.drop(-1)', 'source.drop' is undefined)
+
@@ -0,0 +1 @@
+<!-- This file is required for WebKit test infrastructure to run the templated test -->
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+<!-- This file is required for WebKit test infrastructure to run the templated test -->`