XHR: compliant event sequencing on request errors and aborts.

Source/core/xml/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 409 matching lines @@
     }
 }
 
 void XMLHttpRequest::dispatchReadyStateChangeEvent()
 {
     if (!executionContext())
         return;
 
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchXHRReadyStateChangeEvent(executionContext(), this);
 
-    if (m_async || (m_state <= OPENED || m_state == DONE))
-        m_progressEventThrottle.dispatchReadyStateChangeEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::readystatechange), m_state == DONE ? FlushProgressEvent : DoNotFlushProgressEvent);
+    if (m_async || (m_state <= OPENED || m_state == DONE)) {
+        ProgressEventAction flushAction = DoNotFlushProgressEvent;
+        if (m_state == DONE) {
+            if (m_error)
+                flushAction = FlushDeferredProgressEvent;
+            else
+                flushAction = FlushProgressEvent;
+        }
+        m_progressEventThrottle.dispatchReadyStateChangeEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::readystatechange), flushAction);
+    }
 
     InspectorInstrumentation::didDispatchXHRReadyStateChangeEvent(cookie);
     if (m_state == DONE && !m_error) {
         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchXHRLoadEvent(executionContext(), this);
         m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::load));
         InspectorInstrumentation::didDispatchXHRLoadEvent(cookie);
         m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::loadend));
     }
 }
 
@@ skipping 407 matching lines @@
     bool sendFlag = m_loader;
 
     if (!internalAbort())
         return;
 
     clearResponse();
 
     // Clear headers as required by the spec
     m_requestHeaders.clear();
 
-    if ((m_state <= OPENED && !sendFlag) || m_state == DONE) {
-        // No readystatechange event is dispatched.
-        m_state = UNSENT;
-        return;
+    if (!((m_state <= OPENED && !sendFlag) || m_state == DONE)) {
+        ASSERT(!m_loader);
+        handleRequestError(0, EventTypeNames::abort);
     }
-
-    ASSERT(!m_loader);
-    changeState(DONE);
     m_state = UNSENT;
-
-    m_progressEventThrottle.dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(EventTypeNames::abort));
-    if (!m_uploadComplete) {
-        m_uploadComplete = true;
-        if (m_upload && m_uploadEventsAllowed)
-            m_upload->dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(EventTypeNames::abort));
-    }
 }
 
 void XMLHttpRequest::clearVariablesForLoading()
 {
     // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization.
     m_receivedLength = 0;
     m_decoder = 0;
 
     m_responseEncoding = String();
 }
@@ skipping 86 matching lines @@
     bool lengthComputable = expectedLength > 0 && m_receivedLength <= expectedLength;
     unsigned long long total = lengthComputable ? expectedLength : 0;
 
     m_progressEventThrottle.dispatchProgressEvent(lengthComputable, m_receivedLength, total);
 }
 
 void XMLHttpRequest::handleNetworkError()
 {
     LOG(Network, "XMLHttpRequest %p handleNetworkError()", this);
 
-    m_exceptionCode = NetworkError;
-
     handleDidFailGeneric();
-
-    if (m_async) {
-        changeState(DONE);
-        dispatchEventAndLoadEnd(EventTypeNames::error);
-    } else {
-        m_state = DONE;
-    }
-
+    handleRequestError(NetworkError, EventTypeNames::error);
     internalAbort();
 }
 
 void XMLHttpRequest::handleDidCancel()
 {
     LOG(Network, "XMLHttpRequest %p handleDidCancel()", this);
 
-    m_exceptionCode = AbortError;
+    handleDidFailGeneric();
+    handleRequestError(AbortError, EventTypeNames::abort);
+}
 
-    handleDidFailGeneric();
+void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type)
+{
+    LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
 
-    if (!m_async) {
+    // The request error steps for event 'type' and exception 'exceptionCode'.
+
+    if (!m_async && exceptionCode) {
         m_state = DONE;
+        m_exceptionCode = exceptionCode;
         return;
     }
+    // With m_error set, the state change steps are minimal: any pending
+    // progress event is flushed + a readystatechange is dispatched.
+    // No new progress events dispatched; as required, that happens at
+    // the end here.
+    ASSERT(m_error);
     changeState(DONE);
 
-    dispatchEventAndLoadEnd(EventTypeNames::abort);
+    if (!m_uploadComplete) {
+        m_uploadComplete = true;
+        if (m_upload && m_uploadEventsAllowed)
+            m_upload->handleRequestError(type);
+    }
+
+    dispatchThrottledProgressEvent();
+    m_progressEventThrottle.dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(type));
 }
 
 void XMLHttpRequest::dropProtectionSoon()
 {
     m_dropProtectionRunner.runAsync();
 }
 
 void XMLHttpRequest::dropProtection()
 {
     unsetPendingActivity(this);
@@ skipping 305 matching lines @@
 void XMLHttpRequest::handleDidTimeout()
 {
     LOG(Network, "XMLHttpRequest %p handleDidTimeout()", this);
 
     // internalAbort() calls dropProtection(), which may release the last reference.
     RefPtr<XMLHttpRequest> protect(this);
 
     if (!internalAbort())
         return;
 
-    m_exceptionCode = TimeoutError;
-
     handleDidFailGeneric();
-
-    if (!m_async) {
-        m_state = DONE;
-        return;
-    }
-    changeState(DONE);
-
-    dispatchEventAndLoadEnd(EventTypeNames::timeout);
+    handleRequestError(TimeoutError, EventTypeNames::timeout);
 }
 
 void XMLHttpRequest::suspend()
 {
     m_progressEventThrottle.suspend();
 }
 
 void XMLHttpRequest::resume()
 {
     m_progressEventThrottle.resume();
@@ skipping 14 matching lines @@
 {
     return EventTargetNames::XMLHttpRequest;
 }
 
 ExecutionContext* XMLHttpRequest::executionContext() const
 {
     return ActiveDOMObject::executionContext();
 }
 
 } // namespace WebCore