bool XMLHttpRequest::internalAbort() { m_error = true; // 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; if (!m_loader) return true; // Cancelling m_loader may trigger a window.onload callback which can call open() on the same xhr. // This would create internalAbort reentrant call. // m_loader is set to null before being cancelled to exit early in any reentrant internalAbort() call. RefPtr<ThreadableLoader> loader = m_loader.release(); loader->cancel(); // If window.onload callback calls open() and send() on the same xhr, m_loader is now set to a new value. // The function calling internalAbort() should abort to let the open() and send() calls continue properly. // We ask the function calling internalAbort() to exit by returning false. // Save this information to a local variable since we are going to drop protection. bool newLoadStarted = m_loader; dropProtection(); return !newLoadStarted; }
bool XMLHttpRequest::internalAbort(DropProtection async) { m_error = true; clearVariablesForLoading(); InspectorInstrumentation::didFailXHRLoading(executionContext(), this, this); if (m_responseStream && m_state != DONE) m_responseStream->abort(); if (!m_loader) return true; // Cancelling the ThreadableLoader m_loader may result in calling // window.onload synchronously. If such an onload handler contains open() // call on the same XMLHttpRequest object, reentry happens. If m_loader // is left to be non 0, internalAbort() call for the inner open() makes // an extra dropProtection() call (when we're back to the outer open(), // we'll call dropProtection()). To avoid that, clears m_loader before // calling cancel. // // If, window.onload contains open() and send(), m_loader will be set to // non 0 value. So, we cannot continue the outer open(). In such case, // just abort the outer open() by returning false. RefPtr<ThreadableLoader> loader = m_loader.release(); loader->cancel(); // Save to a local variable since we're going to drop protection. bool newLoadStarted = m_loader; // If abort() called internalAbort() and a nested open() ended up // clearing the error flag, but didn't send(), make sure the error // flag is still set. if (!newLoadStarted) m_error = true; if (async == DropProtectionAsync) dropProtectionSoon(); else dropProtection(); return !newLoadStarted; }
void XMLHttpRequest::internalAbort() { bool hadLoader = m_loader; m_error = true; // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization. m_receivedLength = 0; if (hadLoader) { m_loader->cancel(); m_loader = 0; } m_decoder = 0; if (hadLoader) dropProtection(); }
void XMLHttpRequest::internalAbort() { bool hadLoader = m_loader; m_error = true; // FIXME: when we add the support for multi-part XHR, we will have to think be careful with this initialization. m_receivedLength = 0; if (hadLoader) { m_loader->cancel(); m_loader = 0; } m_decoder = 0; InspectorInstrumentation::didFailXHRLoading(scriptExecutionContext(), this); if (hadLoader) dropProtection(); }
void XMLHttpRequest::networkErrorTimerFired() { networkError(); dropProtection(); }