XHR.abort(): no event dispatching in completed/non-started states.

LayoutTests/http/tests/xmlhttprequest/timeout/xmlhttprequest-timeout.js

 /* Test imported from Alex Vincent's XHR2 timeout tests, written for Mozilla.
    https://hg.mozilla.org/mozilla-central/file/tip/content/base/test/
    Released into the public domain, according to
    https://bugzilla.mozilla.org/show_bug.cgi?id=525816#c86
 */
 
 /* Notes:
    - All times are expressed in milliseconds in this test suite.
    - Test harness code is at the end of this file.
    - We generate only one request at a time, to avoid overloading the HTTP
@@ skipping 175 matching lines @@
     this.request = req;
     req.open("GET", STALLED_REQUEST_URL);
     var me = this;
     function handleEvent(e) { return me.handleEvent(e); };
     req.onerror = handleEvent;
     req.onload = handleEvent;
     req.onabort = handleEvent;
     req.ontimeout = handleEvent;
 
     req.timeout = TIME_REGULAR_TIMEOUT;
-    var _this = this;
 
     function abortReq() {
-      req.abort();
+      if (me.request.readyState == XMLHttpRequest.DONE || me.request.readyState > XMLHttpRequest.OPENED) {

[tyoshino (SeeGerritForStatus), 2013/11/07 13:38:05]

maybe this should be
me.request.readyState < XMLHttpRequest.OPENED
but we don't hit this bug?

this code was hard to read before your change. i'll do some refactoring.

[sof, 2013/11/07 14:34:14]

Much better, that was the intent & close enough (i.e., you could still be in
OPENED, pre-send(), and have abort() not dispatch any progress events.) But none
of the tests here exercises such early calls to abort(), afaict.

[The upstream Mozilla version doesn't have this extra condition & silently
completes the final AbortedRequest() (for "aborted") test without outputting
PASS.]

+        if (me.abortDelay > TIME_REGULAR_TIMEOUT)
+          me.timeoutEventFired()
+        else
+          me.noEventsFired();
+      } else
+          req.abort();
     }
 
     if (!this.shouldAbort) {
       self.setTimeout(function() {
         try {
-          _this.noEventsFired();
+          me.noEventsFired();
         }
         catch (e) {
           ok(false, "Unexpected error: " + e);
           TestCounter.testComplete();
         }
       }, TIME_NORMAL_LOAD);
     }
     else {
       // Abort events can only be triggered on sent requests.
       req.send();
       if (this.abortDelay == -1) {
         abortReq();
       }
       else {
         self.setTimeout(abortReq, this.abortDelay);
       }
     }
   },
 
   /**
    * Ensure that no events fired at all, especially not our timeout event.
    */
   noEventsFired: function() {
     ok(!this.hasFired, "No events should fire for an unsent, unaborted request");
     // We're done; if timeout hasn't fired by now, it never will.
     TestCounter.testComplete();
   },
 
   /**
+   * Ensure that an event fired, our timeout event.
+   */
+  timeoutEventFired: function() {
+    ok(this.hasFired && this.eventFired == "timeout", "A timeout event should have fired");
+    TestCounter.testComplete();
+  },
+
+  /**
    * Get a message describing this test.
    *
    * @returns {String} The test description.
    */
   getMessage: function() {
     return "time to abort is " + this.abortDelay + ", timeout set at " + TIME_REGULAR_TIMEOUT;
   },
 
   /**
    * Check the event received, and if it's the right (and only) one we get.
    *
-   * WebKit fires abort events even for DONE and UNSENT states, which is 
-   * discussed in http://webkit.org/b/98404
-   * That's why we chose to accept secondary "abort" events in this test.
-   *
    * @param {DOMProgressEvent} evt An event of type "load" or "timeout".
    */
   handleEvent: function(evt) {
-    if (this.hasFired && evt.type != "abort") {
-      ok(false, "Only abort event should fire: " + this.getMessage());
+    if (this.hasFired) {
+      ok(false, "Only one event should fire: " + this.getMessage());
       return;
     }
 
-    var expectedEvent = (this.abortDelay >= TIME_REGULAR_TIMEOUT && !this.hasFired) ? "timeout" : "abort";
+    var expectedEvent = (this.abortDelay >= TIME_REGULAR_TIMEOUT) ? "timeout" : "abort";
     this.hasFired = true;
+    this.eventFired = evt.type;
     is(evt.type, expectedEvent, this.getMessage());
     TestCounter.testComplete();
   }
 };
 
 var SyncRequestSettingTimeoutAfterOpen = {
   startXHR: function() {
     var pass = false;
     var req = new XMLHttpRequest();
     req.open("GET", STALLED_REQUEST_URL, false);
@@ skipping 96 matching lines @@
     }
   }
 };
 
 self.addEventListener("message", function (event) {
   if (event.data.type == "start") {
     TestRequests = TestRequestGroups[event.data.group];
     TestCounter.next();
   }
 });