XHR: separate delayed progress event flushing from dispatching of new.

Source/core/xml/XMLHttpRequestProgressEventThrottle.cpp

 /*
  * Copyright (C) 2010 Julien Chaffraix <jchaffraix@webkit.org>  All right reserved.
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 59 matching lines @@
     }
 
     // The timer is already active so minimumProgressEventDispatchingIntervalInSeconds is the least frequent event.
     m_lengthComputable = lengthComputable;
     m_loaded = loaded;
     m_total = total;
 }
 
 void XMLHttpRequestProgressEventThrottle::dispatchReadyStateChangeEvent(PassRefPtr<Event> event, ProgressEventAction progressEventAction)
 {
-    if (progressEventAction == FlushProgressEvent)
-        flushProgressEvent();
+    if (progressEventAction == FlushProgressEvent || progressEventAction == FlushDeferredProgressEvent) {
+        if (!flushDeferredProgressEvent() && progressEventAction == FlushProgressEvent)
+            deliverProgressEvent();
+    }
 
     dispatchEvent(event);
 }
 
 void XMLHttpRequestProgressEventThrottle::dispatchEvent(PassRefPtr<Event> event)
 {
     ASSERT(event);
     if (m_deferEvents) {
         if (m_deferredEvents.size() > 1 && event->type() == EventTypeNames::readystatechange && event->type() == m_deferredEvents.last()->type()) {
             // Readystatechange events are state-less so avoid repeating two identical events in a row on resume.
             return;
         }
         m_deferredEvents.append(event);
     } else
         m_target->dispatchEvent(event);
 }
 
 void XMLHttpRequestProgressEventThrottle::dispatchEventAndLoadEnd(PassRefPtr<Event> event)
 {
     ASSERT(event->type() == EventTypeNames::load || event->type() == EventTypeNames::abort || event->type() == EventTypeNames::error || event->type() == EventTypeNames::timeout);
 
     dispatchEvent(event);
     dispatchEvent(XMLHttpRequestProgressEvent::create(EventTypeNames::loadend));
 }
 
-void XMLHttpRequestProgressEventThrottle::flushProgressEvent()
+bool XMLHttpRequestProgressEventThrottle::flushDeferredProgressEvent()
 {
     if (m_deferEvents && m_deferredProgressEvent) {
         // Move the progress event to the queue, to get it in the right order on resume.
         m_deferredEvents.append(m_deferredProgressEvent);
         m_deferredProgressEvent = 0;
-        return;
+        return true;
     }
+    return false;
+}
 
+void XMLHttpRequestProgressEventThrottle::deliverProgressEvent()
+{
     if (!hasEventToDispatch())
         return;
 
     PassRefPtr<Event> event = XMLHttpRequestProgressEvent::create(EventTypeNames::progress, m_lengthComputable, m_loaded, m_total);
     m_loaded = 0;
     m_total = 0;
 
     // We stop the timer as this is called when no more events are supposed to occur.
     stop();
 
@@ skipping 78 matching lines @@
     }
 
     // Do not dispatch events inline here, since ExecutionContext is iterating over
     // the list of active DOM objects to resume them, and any activated JS event-handler
     // could insert new active DOM objects to the list.
     // m_deferEvents is kept true until all deferred events have been dispatched.
     m_dispatchDeferredEventsTimer.startOneShot(0);
 }
 
 } // namespace WebCore