--- a/dom/xhr/XMLHttpRequestWorker.cpp
+++ b/dom/xhr/XMLHttpRequestWorker.cpp
@@ -4,17 +4,16 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "XMLHttpRequestWorker.h"
#include "nsIDOMEvent.h"
#include "nsIDOMEventListener.h"
#include "nsIRunnable.h"
-#include "nsIXMLHttpRequest.h"
#include "nsIXPConnect.h"
#include "jsfriendapi.h"
#include "js/TracingAPI.h"
#include "js/GCPolicyAPI.h"
#include "mozilla/ArrayUtils.h"
#include "mozilla/dom/Exceptions.h"
#include "mozilla/dom/File.h"
@@ -296,17 +295,17 @@ const char* const sEventStrings[] = {
// XMLHttpRequestEventTarget event types, supported by both XHR and Upload.
"abort",
"error",
"load",
"loadstart",
"progress",
"timeout",
- // nsIXMLHttpRequest event types, supported only by XHR.
+ // XMLHttpRequest event types, supported only by XHR.
"readystatechange",
"loadend",
};
static_assert(MOZ_ARRAY_LENGTH(sEventStrings) == STRING_COUNT,
"Bad string count!");
class MainThreadProxyRunnable : public MainThreadWorkerSyncRunnable
@@ -1004,19 +1003,17 @@ Proxy::HandleEvent(nsIDOMEvent* aEvent)
NS_WARNING("Failed to get target!");
return NS_ERROR_FAILURE;
}
bool isUploadTarget = mXHR != target;
ProgressEvent* progressEvent = aEvent->InternalDOMEvent()->AsProgressEvent();
if (mInOpen && type.EqualsASCII(sEventStrings[STRING_readystatechange])) {
- uint16_t readyState = 0;
- if (NS_SUCCEEDED(mXHR->GetReadyState(&readyState)) &&
- readyState == nsIXMLHttpRequest::OPENED) {
+ if (mXHR->ReadyState() == 1) {
mInnerEventStreamId++;
}
}
{
AutoSafeJSContext cx;
JSAutoRequest ar(cx);
@@ -1130,33 +1127,34 @@ EventRunnable::PreDispatch(WorkerPrivate
JS::Rooted<JSObject*> scopeObj(cx, mScopeObj);
// And reset mScopeObj now, before we have a chance to run its destructor on
// some background thread.
mScopeObj.reset();
RefPtr<XMLHttpRequestMainThread>& xhr = mProxy->mXHR;
MOZ_ASSERT(xhr);
- if (NS_FAILED(xhr->GetResponseType(mResponseType))) {
- MOZ_ASSERT(false, "This should never fail!");
- }
+ const EnumEntry& entry =
+ XMLHttpRequestResponseTypeValues::strings[static_cast<uint32_t>(xhr->ResponseType())];
+ mResponseType.AssignASCII(entry.value, entry.length);
ErrorResult rv;
xhr->GetResponseText(mResponseText, rv);
mResponseTextResult = rv.StealNSResult();
if (NS_SUCCEEDED(mResponseTextResult)) {
mResponseResult = mResponseTextResult;
if (mResponseText.IsVoid()) {
mResponse.setNull();
}
}
else {
JS::Rooted<JS::Value> response(cx);
- mResponseResult = xhr->GetResponse(cx, &response);
+ xhr->GetResponse(cx, &response, rv);
+ mResponseResult = rv.StealNSResult();
if (NS_SUCCEEDED(mResponseResult)) {
if (!response.isGCThing()) {
mResponse = response;
} else {
bool doClone = true;
JS::Rooted<JS::Value> transferable(cx);
JS::Rooted<JSObject*> obj(cx, response.isObject() ?
&response.toObject() : nullptr);
@@ -1169,17 +1167,17 @@ EventRunnable::PreDispatch(WorkerPrivate
} else {
MOZ_ASSERT(!JS_IsDetachedArrayBufferObject(obj));
JS::AutoValueArray<1> argv(cx);
argv[0].set(response);
obj = JS_NewArrayObject(cx, argv);
if (obj) {
transferable.setObject(*obj);
// Only cache the response when the readyState is DONE.
- if (xhr->ReadyState() == nsIXMLHttpRequest::DONE) {
+ if (xhr->ReadyState() == 4) {
mProxy->mArrayBufferResponseWasTransferred = true;
}
} else {
mResponseResult = NS_ERROR_OUT_OF_MEMORY;
doClone = false;
}
}
}
@@ -1191,17 +1189,18 @@ EventRunnable::PreDispatch(WorkerPrivate
mResponseResult = rv.StealNSResult();
mProxy->mArrayBufferResponseWasTransferred = false;
}
}
}
}
}
- mStatusResult = xhr->GetStatus(&mStatus);
+ mStatus = xhr->GetStatus(rv);
+ mStatusResult = rv.StealNSResult();
xhr->GetStatusText(mStatusText, rv);
MOZ_ASSERT(!rv.Failed());
mReadyState = xhr->ReadyState();
xhr->GetResponseURL(mResponseURL);
@@ -1407,52 +1406,55 @@ AbortRunnable::RunOnMainThread(ErrorResu
nsresult
OpenRunnable::MainThreadRunInternal()
{
if (!mProxy->Init()) {
return NS_ERROR_DOM_INVALID_STATE_ERR;
}
- nsresult rv;
-
if (mBackgroundRequest) {
- rv = mProxy->mXHR->SetMozBackgroundRequest(mBackgroundRequest);
+ nsresult rv = mProxy->mXHR->SetMozBackgroundRequest(mBackgroundRequest);
NS_ENSURE_SUCCESS(rv, rv);
}
+ ErrorResult rv;
+
if (mWithCredentials) {
- rv = mProxy->mXHR->SetWithCredentials(mWithCredentials);
- NS_ENSURE_SUCCESS(rv, rv);
+ mProxy->mXHR->SetWithCredentials(mWithCredentials, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
}
if (mTimeout) {
- rv = mProxy->mXHR->SetTimeout(mTimeout);
- NS_ENSURE_SUCCESS(rv, rv);
+ mProxy->mXHR->SetTimeout(mTimeout, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
}
MOZ_ASSERT(!mProxy->mInOpen);
mProxy->mInOpen = true;
- ErrorResult rv2;
mProxy->mXHR->Open(mMethod, mURL, true,
mUser.WasPassed() ? mUser.Value() : VoidString(),
mPassword.WasPassed() ? mPassword.Value() : VoidString(),
- rv2);
+ rv);
MOZ_ASSERT(mProxy->mInOpen);
mProxy->mInOpen = false;
- if (rv2.Failed()) {
- return rv2.StealNSResult();
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
}
- mProxy->mXHR->SetResponseType(mResponseType, rv2);
- if (rv2.Failed()) {
- return rv2.StealNSResult();
+ mProxy->mXHR->SetResponseType(mResponseType, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
}
return NS_OK;
}
void
SendRunnable::RunOnMainThread(ErrorResult& aRv)
{
@@ -2181,20 +2183,20 @@ XMLHttpRequestWorker::Abort(ErrorResult&
if (!mProxy) {
return;
}
// Set our status to 0 and statusText to "" if we
// will be aborting an ongoing fetch, so the upcoming
// abort events we dispatch have the correct info.
- if ((mStateData.mReadyState == nsIXMLHttpRequest::OPENED && mStateData.mFlagSend) ||
- mStateData.mReadyState == nsIXMLHttpRequest::HEADERS_RECEIVED ||
- mStateData.mReadyState == nsIXMLHttpRequest::LOADING ||
- mStateData.mReadyState == nsIXMLHttpRequest::DONE) {
+ if ((mStateData.mReadyState == State::opened && mStateData.mFlagSend) ||
+ mStateData.mReadyState == State::headers_received ||
+ mStateData.mReadyState == State::loading ||
+ mStateData.mReadyState == State::done) {
mStateData.mStatus = 0;
mStateData.mStatusText.Truncate();
}
MaybeDispatchPrematureAbortEvents(aRv);
if (aRv.Failed()) {
return;
}
@@ -2277,17 +2279,17 @@ XMLHttpRequestWorker::OverrideMimeType(c
// We're supposed to throw if the state is not OPENED or HEADERS_RECEIVED. We
// can detect OPENED really easily but we can't detect HEADERS_RECEIVED in a
// non-racy way until the XHR state machine actually runs on this thread
// (bug 671047). For now we're going to let this work only if the Send()
// method has not been called, unless the send has been aborted.
if (!mProxy || (SendInProgress() &&
(mProxy->mSeenLoadStart ||
- mStateData.mReadyState > nsIXMLHttpRequest::OPENED))) {
+ mStateData.mReadyState > 1))) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
RefPtr<OverrideMimeTypeRunnable> runnable =
new OverrideMimeTypeRunnable(mWorkerPrivate, mProxy, aMimeType);
runnable->Dispatch(Terminating, aRv);
}
@@ -2313,17 +2315,17 @@ XMLHttpRequestWorker::SetResponseType(XM
// Open() has not been called yet. We store the responseType and we will use
// it later in Open().
mResponseType = aResponseType;
return;
}
if (SendInProgress() &&
(mProxy->mSeenLoadStart ||
- mStateData.mReadyState > nsIXMLHttpRequest::OPENED)) {
+ mStateData.mReadyState > 1)) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
RefPtr<SetResponseTypeRunnable> runnable =
new SetResponseTypeRunnable(mWorkerPrivate, mProxy, aResponseType);
runnable->Dispatch(Terminating, aRv);
if (aRv.Failed()) {