Improve fidelity of XHR progress events.

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

[tyoshino (SeeGerritForStatus), 2013/11/25 05:06:31]

abarth: sigbjornf has made substantial amount of changes to this file. do you
think it makes sense to add Opera to the copyright list?

  *
  *  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
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
@@ skipping 417 matching lines @@
                 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));
+        dispatchThrottledProgressEvent(EventTypeNames::load);
         InspectorInstrumentation::didDispatchXHRLoadEvent(cookie);
-        m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::loadend));
+        dispatchThrottledProgressEvent(EventTypeNames::loadend);
     }
 }
 
 void XMLHttpRequest::setWithCredentials(bool value, ExceptionState& exceptionState)
 {
     if (m_state > OPENED || m_loader) {
         exceptionState.throwDOMException(InvalidStateError, ExceptionMessages::failedToSet("withCredentials", "XMLHttpRequest", "the value may only be set if the object's state is UNSENT or OPENED."));
         return;
     }
 
@@ skipping 392 matching lines @@
 
 void XMLHttpRequest::abort()
 {
     LOG(Network, "XMLHttpRequest %p abort()", this);
 
     // internalAbort() calls dropProtection(), which may release the last reference.
     RefPtr<XMLHttpRequest> protect(this);
 
     bool sendFlag = m_loader;
 
+    // Response is cleared next, save needed progress event data.
+    long long expectedLength = m_response.expectedContentLength();
+    long long receivedLength = m_receivedLength;
+
     if (!internalAbort())
         return;
 
     clearResponse();
 
     // Clear headers as required by the spec
     m_requestHeaders.clear();
 
     if (!((m_state <= OPENED && !sendFlag) || m_state == DONE)) {
         ASSERT(!m_loader);
-        handleRequestError(0, EventTypeNames::abort);
+        handleRequestError(0, EventTypeNames::abort, receivedLength, expectedLength);
     }
     m_state = UNSENT;
 }
 
 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.clear();
 
@@ skipping 71 matching lines @@
 }
 
 void XMLHttpRequest::handleDidFailGeneric()
 {
     clearResponse();
     clearRequest();
 
     m_error = true;
 }
 
-void XMLHttpRequest::dispatchEventAndLoadEnd(const AtomicString& type)
+void XMLHttpRequest::dispatchEventAndLoadEnd(const AtomicString& type, long long receivedLength, long long expectedLength)
 {
-    if (!m_uploadComplete) {
-        m_uploadComplete = true;
-        if (m_upload && m_uploadEventsAllowed)
-            m_upload->dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(type));
-    }
-    m_progressEventThrottle.dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(type));
+    bool lengthComputable = expectedLength > 0 && receivedLength <= expectedLength;
+    unsigned long long loaded = receivedLength >= 0 ? static_cast<unsigned long long>(receivedLength) : 0;
+    unsigned long long total = lengthComputable ? static_cast<unsigned long long>(expectedLength) : 0;
+
+    m_progressEventThrottle.dispatchEventAndLoadEnd(type, lengthComputable, loaded, total);
 }
 
-void XMLHttpRequest::dispatchThrottledProgressEvent()
+void XMLHttpRequest::dispatchThrottledProgressEvent(const AtomicString& type, long long receivedLength, long long expectedLength)

[tyoshino (SeeGerritForStatus), 2013/11/25 05:06:31]

how about having two methods one takes two arguments, the other uses the member
variables. say... dispatchThrottledProgressEvent and
dispatchThrottledProgressEventUsingSpecifiedValues... the former calls the
latter with m_receivedLength and m_response.expectedContentLength().

it's possible the caller passes 0 to receivedLength and expectedLength. to make
this work correctly for such a case, we need to ensure that m_receivedLength and
m_response.expectedContentLength are set to 0. they're reset where this method
is invoked so, there should be no problem, but it adds time for reviewers to
verify the code.

[sof, 2013/11/25 06:48:12]

Yes, how about dispatchThrottledProgressEventSnapshot() for the one that
defaults to m_receivedLength + m_response values?

 {
-    long long expectedLength = m_response.expectedContentLength();
+    if (!receivedLength)
+        receivedLength = m_receivedLength;
+    if (!expectedLength)
+        expectedLength = m_response.expectedContentLength();
+
     bool lengthComputable = expectedLength > 0 && m_receivedLength <= expectedLength;
-    unsigned long long total = lengthComputable ? expectedLength : 0;
+    unsigned long long loaded = m_receivedLength >= 0 ? static_cast<unsigned long long>(m_receivedLength) : 0;
+    unsigned long long total = lengthComputable ? static_cast<unsigned long long>(expectedLength) : 0;
 
-    m_progressEventThrottle.dispatchProgressEvent(lengthComputable, m_receivedLength, total);
+    if (type == EventTypeNames::progress)
+        m_progressEventThrottle.dispatchProgressEvent(lengthComputable, loaded, total);
+    else
+        m_progressEventThrottle.dispatchEvent(XMLHttpRequestProgressEvent::create(type, lengthComputable, loaded, total));
 }
 
 void XMLHttpRequest::handleNetworkError()
 {
     LOG(Network, "XMLHttpRequest %p handleNetworkError()", this);
 
+    // Response is cleared next, save needed progress event data.
+    long long expectedLength = m_response.expectedContentLength();
+    long long receivedLength = m_receivedLength;
+
     handleDidFailGeneric();
-    handleRequestError(NetworkError, EventTypeNames::error);
+    handleRequestError(NetworkError, EventTypeNames::error, receivedLength, expectedLength);
     internalAbort();
 }
 
 void XMLHttpRequest::handleDidCancel()
 {
     LOG(Network, "XMLHttpRequest %p handleDidCancel()", this);
 
+    // Response is cleared next, save needed progress event data.
+    long long expectedLength = m_response.expectedContentLength();
+    long long receivedLength = m_receivedLength;
+
     handleDidFailGeneric();
-    handleRequestError(AbortError, EventTypeNames::abort);
+    handleRequestError(AbortError, EventTypeNames::abort, receivedLength, expectedLength);
 }
 
-void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type)
+void XMLHttpRequest::handleRequestError(ExceptionCode exceptionCode, const AtomicString& type, long long receivedLength, long long expectedLength)
 {
     LOG(Network, "XMLHttpRequest %p handleRequestError()", this);
 
     // 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);
 
     if (!m_uploadComplete) {
         m_uploadComplete = true;
         if (m_upload && m_uploadEventsAllowed)
             m_upload->handleRequestError(type);
     }
 
-    dispatchThrottledProgressEvent();
-    m_progressEventThrottle.dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(type));
+    dispatchThrottledProgressEvent(EventTypeNames::progress, receivedLength, expectedLength);
+    dispatchEventAndLoadEnd(type, receivedLength, expectedLength);
 }
 
 void XMLHttpRequest::dropProtectionSoon()
 {
     m_dropProtectionRunner.runAsync();
 }
 
 void XMLHttpRequest::dropProtection()
 {
     unsetPendingActivity(this);
@@ skipping 179 matching lines @@
 
     if (m_error)
         return;
 
     if (m_state < HEADERS_RECEIVED)
         changeState(HEADERS_RECEIVED);
 
     if (m_decoder)
         m_responseText = m_responseText.concatenateWith(m_decoder->flush());
 
-    clearVariablesForLoading();
-
     if (m_responseStream)
         m_responseStream->finalize();
 
     InspectorInstrumentation::didFinishXHRLoading(executionContext(), this, identifier, m_responseText, m_url, m_lastSendURL, m_lastSendLineNumber);
 
     // Prevent dropProtection releasing the last reference, and retain |this| until the end of this method.
     RefPtr<XMLHttpRequest> protect(this);
 
     if (m_loader) {
         m_loader = 0;
         dropProtection();
     }
 
     changeState(DONE);
+
+    clearVariablesForLoading();
 }
 
 void XMLHttpRequest::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
 {
     LOG(Network, "XMLHttpRequest %p didSendData(%llu, %llu)", this, bytesSent, totalBytesToBeSent);
 
     if (!m_upload)
         return;
 
     if (m_uploadEventsAllowed)
         m_upload->dispatchProgressEvent(bytesSent, totalBytesToBeSent);
 
     if (bytesSent == totalBytesToBeSent && !m_uploadComplete) {
         m_uploadComplete = true;
         if (m_uploadEventsAllowed)
-            m_upload->dispatchEventAndLoadEnd(XMLHttpRequestProgressEvent::create(EventTypeNames::load));
+            m_upload->dispatchEventAndLoadEnd(EventTypeNames::load, true, bytesSent, totalBytesToBeSent);
     }
 }
 
 void XMLHttpRequest::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
 {
     LOG(Network, "XMLHttpRequest %p didReceiveResponse(%lu)", this, identifier);
 
     InspectorInstrumentation::didReceiveXHRResponse(executionContext(), identifier);
 
     m_response = response;
@@ skipping 50 matching lines @@
             m_responseStream = Stream::create(executionContext(), responseMIMEType());
         m_responseStream->addData(data, len);
     }
 
     if (m_error)
         return;
 
     m_receivedLength += len;
 
     if (m_async)
-        dispatchThrottledProgressEvent();
+        dispatchThrottledProgressEvent(EventTypeNames::progress);
 
     if (m_state != LOADING) {
         changeState(LOADING);
     } else {
         // Firefox calls readyStateChanged every time it receives data. Do
         // the same to align with Firefox.
         //
         // FIXME: Make our implementation and the spec consistent. This
         // behavior was needed when the progress event was not available.
         dispatchReadyStateChangeEvent();
     }
 }
 
 void XMLHttpRequest::handleDidTimeout()
 {
     LOG(Network, "XMLHttpRequest %p handleDidTimeout()", this);
 
     // internalAbort() calls dropProtection(), which may release the last reference.
     RefPtr<XMLHttpRequest> protect(this);
 
+    // Response is cleared next, save needed progress event data.
+    long long expectedLength = m_response.expectedContentLength();
+    long long receivedLength = m_receivedLength;
+
     if (!internalAbort())
         return;
 
     handleDidFailGeneric();
-    handleRequestError(TimeoutError, EventTypeNames::timeout);
+    handleRequestError(TimeoutError, EventTypeNames::timeout, receivedLength, expectedLength);
 }
 
 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