This callback will be called when the XHR progresses in its load.

@method _onProgress
@protected
@param  {XMLHttpRequestProgressEvent} ev This event contains data for the progress of the load
508601
function (ev) {
    var loaded = ev.loaded || ev.position;
    var totalSize = ev.total || ev.totalSize;

    if (totalSize) {
      this._dispatchProgress(loaded / totalSize);
    } else {
      this._dispatchProgress(0);
    }
  }
232294
@Override
    public void onProgress(final StreamingProgressEvent event) {
        assertStateConsistency(fileUploadId, event.getFileName());

        if (event.getBytesReceived() > maxSize || event.getContentLength() > maxSize) {
            LOG.error("User tried to upload more than was allowed ({}).", maxSize);
            interruptUploadDueToFileSizeExceeded(maxSize);
            return;
        }
        if (isUploadInterrupted()) {
            return;
        }

        publishUploadProgressEvent(fileUploadId, event.getBytesReceived(), event.getContentLength());
    }
1165087
function(fallbackImage, onProgress) {
    /**
     * @type {?function({status: boolean, value: HTMLImageElement})}
     */
    this.onProgress = typeof onProgress === 'function' ? onProgress : null;
    /**
     * @type {?String|HTMLImageElement}
     */
    this.fallbackImage = typeof fallbackImage === 'string' || fallbackImage instanceof HTMLImageElement ? fallbackImage : null;
}
1374866
private void onPushLevelProgress(int steps, Object source, boolean singlesteplevel)
    {
        if (this.currentStep.isLevelFinished()) {
            // If current step is done move to next one
            this.currentStep = this.currentStep.getParent().nextStep(null, source);
        }

        // Add level
        this.currentStep = this.currentStep.addLevel(steps, source, singlesteplevel);
    }
1065452
public boolean notifyProgress(int value, int maximum) {
    this.value = value;
    this.maximum = maximum;
    this.progress = (double) value / (double) maximum;
    return !isCancelPending();
  }
810889
protected synchronized void notifyListenersSpiderProgress(int percentageComplete, int numberCrawled,
			int numberToCrawl) {
		for (SpiderListener l : listeners) {
			l.spiderProgress(percentageComplete, numberCrawled, numberToCrawl);
		}
	}
879108
public void showProgress(boolean show) {
        if (actionButton != null) {
            actionButton.showProgress(show);
        }
        if (formLayout != null) {
            formLayout.setEnabled(!show);
        }
    }
1098951
ProgressEvent updateProgress(double val, long now) {
		if (val<0 || val>1) {
			throw new IllegalArgumentException("Value out of range [0, 1]: " + val);
		}
		if (val<=progress.getProgress()) {
			reset(start);
		}
		double pD = val - progress.getProgress();
		long tD = now - tstamp;
		if (step > 0) {
			step = step * 0.3 + (tD / pD) * 0.7; 
		} else {
			step = (tD / pD);
		}
		double etcMs = step * (1 - val);
		progress = new ProgressEvent(val, new Date(now + (long)Math.round(etcMs)));
		tstamp = now;
		return progress;
	}
498157
function process (ev) {
				ev = ev || global.event;
				// detect when it's done loading
				// ev.type == 'load' is for all browsers except IE6-9
				// IE6-9 need to use onreadystatechange and look for
				// el.readyState in {loaded, complete} (yes, we need both)
				if (ev.type == 'load' || readyStates[el.readyState]) {
					delete activeScripts[def.id];
					// release event listeners
					el.onload = el.onreadystatechange = el.onerror = ''; // ie cries if we use undefined
					success();
				}
			}
1342228
private void showProgress() {

        removeContent();
        displayDialogInfo(
            org.opencms.gwt.client.Messages.get().key(org.opencms.gwt.client.Messages.GUI_UPLOAD_INFO_UPLOADING_0),
            false);
        m_selectionSummary.removeFromParent();
        List<String> files = new ArrayList<String>(getFilesToUpload().keySet());
        Collections.sort(files, String.CASE_INSENSITIVE_ORDER);
        m_progressInfo = new CmsUploadProgressInfo(files);
        m_progressInfo.setContentLength(m_contentLength);
        m_contentWrapper.add(m_progressInfo);
        m_updateProgressTimer.scheduleRepeating(UPDATE_PROGRESS_INTERVALL);
        startLoadingAnimation(Messages.get().key(Messages.GUI_UPLOAD_CLIENT_LOADING_0), 0);
        setHeight();
        changeHeight();
    }
1339179
function JssorSliderProgressChangeEventHandler(slideIndex, progress, progressBegin, idleBegin, idleEnd, progressEnd) {
    //this event fires continuously within the process of current slide
    //tipical usage
    var progressString = Math.round(progress / progressEnd * 100) + "%";

    var args = [slideIndex, progress, progressBegin, idleBegin, idleEnd, progressEnd];
    console.log(" args: " + args.join(","));
}
766751
function(data, onProgress) {
        onProgress = onProgress || function() {};
        return new Promise(function(resolve, reject) {
            try {
                let obj = JSON.parse(data);
                _.forEach(obj.languages, function (questionnaire, index) {
                    // format
                    questionnaire.language_slug = questionnaire.slug;
                    questionnaire.language_name = questionnaire.name;
                    questionnaire.td_id = questionnaire.questionnaire_id;
                    questionnaire.language_direction = questionnaire.dir.toLowerCase() === 'rtl' ? 'rtl' : 'ltr';

                    try {
                        let id = library.addQuestionnaire(questionnaire);
                        if (id > 0) {
                            // add questions
                            _.forEach(questionnaire.questions, function (question, n) {
                                // format question
                                question.is_required = question.required ? 1 : 0;
                                question.depends_on = question.depends_on === null ? -1 : question.depends_on;
                                question.td_id = question.id;

                                try {
                                    library.addQuestion(question, id);
                                } catch (err) {
                                    console.error('Failed to add question', question);
                                    reject(err);
                                    return;
                                }
                                // broadcast itemized progress if there is only one questionnaire
                                if (obj.languages.length == 1) {
                                    onProgress(questionnaire.questions.length, n + 1);
                                }
                            });
                        } else {
                            console.error('Failed to add questionnaire', questionnaire);
                        }
                    } catch (err) {
                        console.error('Failed to add questionnaire', questionnaire);
                        reject(err);
                        return;
                    }
                    // broadcast overall progress if there are multiple questionnaires.
                    if (obj.languages.length > 1) {
                        onProgress(obj.languages.length, index + 1);
                    }
                });
                resolve();
            } catch (err) {
                reject(err);
            }
        });
    }
993762
public void showValidationInProgress() {
        validationIcon.setValue(null);
        validationIcon.addStyleName("show-status-label");
        validationIcon.setStyleName(SPUIStyleDefinitions.TARGET_FILTER_SEARCH_PROGRESS_INDICATOR_STYLE);
    }
696712
function(inXhr) {
		if (inXhr.onload) {
			inXhr.onload = null;
		}
		if (inXhr.onreadystatechange) {
			inXhr.onreadystatechange = null;
		}
		if (inXhr.abort) {
			inXhr.abort();
		}
	}
592138
function (e) {
                var that = $(this).data('blueimp-fileupload') ||
                        $(this).data('fileupload');
                that._resetFinishedDeferreds();
                that._transition($(this).find('.fileupload-progress')).done(
                    function () {
                        that._trigger('started', e);
                    }
                );
            }
1075468
function (r) {
            // If DONE (cancelled), then don't do anything
            if (me._readyState === FileReader.DONE) {
                return;
            }

            // DONE state
            me._readyState = FileReader.DONE;

            if (r instanceof Array) {
                r = new Uint8Array(r).buffer;
            }
            me._result = r;

            // If onload callback
            if (typeof me.onload === 'function') {
                me.onload(new ProgressEvent('load', { target:me }));
            }

            // If onloadend callback
            if (typeof me.onloadend === 'function') {
                me.onloadend(new ProgressEvent('loadend', { target:me }));
            }
        }
714023
function JssorSliderStateChangeEventHandler(slideIndex, progress, progressBegin, idleBegin, idleEnd, progressEnd) {
    //given a slide parked, the life cycle of current slide is as below, progressBegin --> idleBegin --> idleEnd --> progressEnd
    //this event fires at any state of 'progressBegin', 'idleBegin', 'idleEnd' and 'progressEnd'
    //slideIndex: the index of slide
    //progress: current time (in milliseconds) in the whole process
    //progressBegin: the begining of the whole process (generally, starts to play slideshow and caption)
    //idleBegin: comes to the idle period, will wait for a period which is specified by option '$Idle'
    //idleEnd: the idle period is over, plays the rest caption
    //progressEnd: the whole process is completed

    //tipical usage
    if (progress == progressEnd) {
        //the animation of current slide is completed
    }
    else if (progress == idleEnd) {
        //the idle period of current slide is over
    }
    else if (progress == idleBegin) {
        //comes to the idle period
    }
    else if (progress == progressBegin) {
        //the animation of current slide is at the beginning
    }
    else if (progress < 0) {
        //the animation of current slide is aborted, the progress value is negative only in this case
        var realProgress = -progress - 1;
    }

    var args = [slideIndex, progress, progressBegin, idleBegin, idleEnd, progressEnd];
    console.log(" args: " + args.join(","));
}