NS_IMETHODIMP
SmsRequest::GetError(nsAString& aError)
{
if (!mDone) {
NS_ASSERTION(mError == eNoError,
"There should be no error if the request is still processing!");
SetDOMStringToNull(aError);
return NS_OK;
}
NS_ASSERTION(mError == eNoError || mResult == JSVAL_VOID,
"mResult should be void when there is an error!");
switch (mError) {
case eNoError:
SetDOMStringToNull(aError);
break;
case eNoSignalError:
aError.AssignLiteral("NoSignalError");
break;
case eNotFoundError:
aError.AssignLiteral("NotFoundError");
break;
case eUnknownError:
aError.AssignLiteral("UnknownError");
break;
case eInternalError:
aError.AssignLiteral("InternalError");
break;
}
return NS_OK;
}
nsresult
DOMStorageCache::RemoveItem(const DOMStorage* aStorage, const nsAString& aKey,
nsString& aOld)
{
Telemetry::AutoTimer<Telemetry::LOCALDOMSTORAGE_REMOVEKEY_MS> autoTimer;
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_REMOVEKEY_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
return NS_SUCCESS_DOM_NO_OPERATION;
}
// Recalculate the cached data size
const int64_t delta = -(static_cast<int64_t>(aOld.Length()));
unused << ProcessUsageDelta(aStorage, delta);
data.mKeys.Remove(aKey);
if (Persist(aStorage)) {
return sDatabase->AsyncRemoveItem(this, aKey);
}
return NS_OK;
}
FileReader::FileReader(nsIGlobalObject* aGlobal,
WeakWorkerRef* aWorkerRef)
: DOMEventTargetHelper(aGlobal)
, mFileData(nullptr)
, mDataLen(0)
, mDataFormat(FILE_AS_BINARY)
, mResultArrayBuffer(nullptr)
, mProgressEventWasDelayed(false)
, mTimerIsActive(false)
, mReadyState(EMPTY)
, mTotal(0)
, mTransferred(0)
, mBusyCount(0)
, mWeakWorkerRef(aWorkerRef)
{
MOZ_ASSERT(aGlobal);
MOZ_ASSERT_IF(NS_IsMainThread(), !mWeakWorkerRef);
if (NS_IsMainThread()) {
mTarget = aGlobal->EventTargetFor(TaskCategory::Other);
} else {
mTarget = GetCurrentThreadSerialEventTarget();
}
SetDOMStringToNull(mResult);
}
void
FileReader::Abort()
{
if (mReadyState == EMPTY || mReadyState == DONE) {
return;
}
MOZ_ASSERT(mReadyState == LOADING);
ClearProgressEventTimer();
mReadyState = DONE;
// XXX The spec doesn't say this
mError = DOMException::Create(NS_ERROR_DOM_ABORT_ERR);
// Revert status and result attributes
SetDOMStringToNull(mResult);
mResultArrayBuffer = nullptr;
mAsyncStream = nullptr;
mBlob = nullptr;
//Clean up memory buffer
FreeFileData();
// Dispatch the events
DispatchProgressEvent(NS_LITERAL_STRING(ABORT_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
nsresult
nsDOMStorage::GetItem(const nsAString& aKey, nsAString &aData)
{
nsresult rv;
// IMPORTANT:
// CacheStoragePermissions() is called inside of
// GetItem(nsAString, nsIDOMStorageItem)
// To call it particularly in this method would just duplicate
// the call. If the code changes, make sure that call to
// CacheStoragePermissions() is put here!
nsCOMPtr<nsIDOMStorageItem> item;
rv = GetItem(aKey, getter_AddRefs(item));
if (NS_FAILED(rv))
return rv;
if (item) {
rv = item->GetValue(aData);
NS_ENSURE_SUCCESS(rv, rv);
}
else
SetDOMStringToNull(aData);
return NS_OK;
}
nsresult
nsDOMStorage::GetDBValue(const nsAString& aKey, nsAString& aValue,
PRBool* aSecure)
{
aValue.Truncate();
#ifdef MOZ_STORAGE
if (!UseDB())
return NS_OK;
nsresult rv = InitDB();
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString value;
rv = gStorageDB->GetKeyValue(this, aKey, value, aSecure);
if (rv == NS_ERROR_DOM_NOT_FOUND_ERR && mLocalStorage) {
SetDOMStringToNull(aValue);
}
if (NS_FAILED(rv))
return rv;
if (!IsCallerSecure() && *aSecure) {
return NS_ERROR_DOM_SECURITY_ERR;
}
aValue.Assign(value);
#endif
return NS_OK;
}
nsresult
SessionStorageCache::SetItem(DataSetType aDataSetType, const nsAString& aKey,
const nsAString& aValue, nsString& aOldValue)
{
int64_t delta = 0;
DataSet* dataSet = Set(aDataSetType);
if (!dataSet->mKeys.Get(aKey, &aOldValue)) {
SetDOMStringToNull(aOldValue);
// We only consider key size if the key doesn't exist before.
delta = static_cast<int64_t>(aKey.Length());
}
delta += static_cast<int64_t>(aValue.Length()) -
static_cast<int64_t>(aOldValue.Length());
if (aValue == aOldValue &&
DOMStringIsNull(aValue) == DOMStringIsNull(aOldValue)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
if (!dataSet->ProcessUsageDelta(delta)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
dataSet->mKeys.Put(aKey, nsString(aValue));
return NS_OK;
}
nsresult
DOMStorageCache::RemoveItem(const DOMStorage* aStorage, const nsAString& aKey,
nsString& aOld)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_REMOVEKEY_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
return NS_SUCCESS_DOM_NO_OPERATION;
}
// Recalculate the cached data size
const int64_t delta = -(static_cast<int64_t>(aOld.Length()) +
static_cast<int64_t>(aKey.Length()));
Unused << ProcessUsageDelta(aStorage, delta);
data.mKeys.Remove(aKey);
if (Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
return sDatabase->AsyncRemoveItem(this, aKey);
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMDocumentType::GetNodeValue(nsAString& aNodeValue)
{
SetDOMStringToNull(aNodeValue);
return NS_OK;
}
void
FileReader::Abort(ErrorResult& aRv)
{
if (mReadyState != LOADING) {
// XXX The spec doesn't say this
aRv.Throw(NS_ERROR_DOM_FILE_ABORT_ERR);
return;
}
ClearProgressEventTimer();
mReadyState = DONE;
// XXX The spec doesn't say this
mError = new DOMError(GetOwner(), NS_LITERAL_STRING("AbortError"));
// Revert status and result attributes
SetDOMStringToNull(mResult);
mResultArrayBuffer = nullptr;
mAsyncStream = nullptr;
mBlob = nullptr;
//Clean up memory buffer
FreeFileData();
// Dispatch the events
DispatchProgressEvent(NS_LITERAL_STRING(ABORT_STR));
DispatchProgressEvent(NS_LITERAL_STRING(LOADEND_STR));
}
void
MouseEvent::GetRegion(nsAString& aRegion)
{
SetDOMStringToNull(aRegion);
WidgetMouseEventBase* mouseEventBase = mEvent->AsMouseEventBase();
if (mouseEventBase) {
aRegion = mouseEventBase->region;
}
}
NS_IMETHODIMP
nsXFormsAccessors::GetValue(nsAString &aValue)
{
if (mDelegate) {
mDelegate->GetValue(aValue);
} else {
SetDOMStringToNull(aValue);
}
return NS_OK;
}
NS_IMETHODIMP
nsAccessibleDOMStringList::Item(uint32_t aIndex, nsAString& aResult)
{
if (aIndex >= mNames.Length())
SetDOMStringToNull(aResult);
else
aResult = mNames.ElementAt(aIndex);
return NS_OK;
}
void
SessionStorageCache::GetItem(DataSetType aDataSetType, const nsAString& aKey,
nsAString& aResult)
{
// not using AutoString since we don't want to copy buffer to result
nsString value;
if (!Set(aDataSetType)->mKeys.Get(aKey, &value)) {
SetDOMStringToNull(value);
}
aResult = value;
}
void
IDBIndex::GetLocale(nsString& aLocale) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(mMetadata);
if (mMetadata->locale().IsEmpty()) {
SetDOMStringToNull(aLocale);
} else {
CopyASCIItoUTF16(mMetadata->locale(), aLocale);
}
}
void
URLSearchParams::Get(const nsAString& aName, nsString& aRetval)
{
SetDOMStringToNull(aRetval);
for (uint32_t i = 0, len = mSearchParams.Length(); i < len; ++i) {
if (mSearchParams[i].mKey.Equals(aName)) {
aRetval.Assign(mSearchParams[i].mValue);
break;
}
}
}
void
IDBIndex::GetLocale(nsString& aLocale) const
{
AssertIsOnOwningThread();
MOZ_ASSERT(mMetadata);
if (mMetadata->locale().IsEmpty()) {
SetDOMStringToNull(aLocale);
} else {
aLocale.AssignWithConversion(mMetadata->locale());
}
}
nsresult
LocalStorageCache::SetItem(const LocalStorage* aStorage, const nsAString& aKey,
const nsString& aValue, nsString& aOld,
const MutationSource aSource)
{
// Size of the cache that will change after this action.
int64_t delta = 0;
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_SETVALUE_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
// We only consider key size if the key doesn't exist before.
delta += static_cast<int64_t>(aKey.Length());
}
delta += static_cast<int64_t>(aValue.Length()) -
static_cast<int64_t>(aOld.Length());
if (!ProcessUsageDelta(aStorage, delta, aSource)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
if (aValue == aOld && DOMStringIsNull(aValue) == DOMStringIsNull(aOld)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
data.mKeys.Put(aKey, aValue);
if (aSource == ContentMutation && Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
if (DOMStringIsNull(aOld)) {
return sDatabase->AsyncAddItem(this, aKey, aValue);
}
return sDatabase->AsyncUpdateItem(this, aKey, aValue);
}
return NS_OK;
}
NS_IMETHODIMP
StyleSheet::GetHref(nsAString& aHref)
{
if (nsIURI* sheetURI = SheetInfo().mOriginalSheetURI) {
nsAutoCString str;
nsresult rv = sheetURI->GetSpec(str);
NS_ENSURE_SUCCESS(rv, rv);
CopyUTF8toUTF16(str, aHref);
} else {
SetDOMStringToNull(aHref);
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMTokenList::Item(PRUint32 aIndex, nsAString& aResult)
{
const nsAttrValue* attr = GetParsedAttr();
if (!attr || aIndex >= static_cast<PRUint32>(attr->GetAtomCount())) {
SetDOMStringToNull(aResult);
return NS_OK;
}
attr->AtomAt(aIndex)->ToString(aResult);
return NS_OK;
}
void
nsNodeInfo::GetLocalName(nsAString& aLocalName) const
{
#ifdef STRICT_DOM_LEVEL2_LOCALNAME
if (mInner.mNamespaceID > 0) {
mInner.mName->ToString(aLocalName);
} else {
SetDOMStringToNull(aLocalName);
}
#else
mInner.mName->ToString(aLocalName);
#endif
}
nsresult
nsNodeInfo::GetNamespaceURI(nsAString& aNameSpaceURI) const
{
nsresult rv = NS_OK;
if (mInner.mNamespaceID > 0) {
rv = nsContentUtils::NameSpaceManager()->GetNameSpaceURI(mInner.mNamespaceID,
aNameSpaceURI);
} else {
SetDOMStringToNull(aNameSpaceURI);
}
return rv;
}
NS_IMETHODIMP
SmsRequest::GetError(nsAString& aError)
{
if (!mDone) {
NS_ASSERTION(mError == nsISmsRequestManager::SUCCESS_NO_ERROR,
"There should be no error if the request is still processing!");
SetDOMStringToNull(aError);
return NS_OK;
}
NS_ASSERTION(mError == nsISmsRequestManager::SUCCESS_NO_ERROR ||
mResult == JSVAL_VOID,
"mResult should be void when there is an error!");
switch (mError) {
case nsISmsRequestManager::SUCCESS_NO_ERROR:
SetDOMStringToNull(aError);
break;
case nsISmsRequestManager::NO_SIGNAL_ERROR:
aError.AssignLiteral("NoSignalError");
break;
case nsISmsRequestManager::NOT_FOUND_ERROR:
aError.AssignLiteral("NotFoundError");
break;
case nsISmsRequestManager::UNKNOWN_ERROR:
aError.AssignLiteral("UnknownError");
break;
case nsISmsRequestManager::INTERNAL_ERROR:
aError.AssignLiteral("InternalError");
break;
default:
MOZ_ASSERT(false, "Unknown error value.");
}
return NS_OK;
}
/* readonly attribute DOMString URL; */
NS_IMETHODIMP
nsSVGDocument::GetURL(nsAString& aURL)
{
SetDOMStringToNull(aURL);
if (mDocumentURI) {
nsCAutoString url;
nsresult rv = mDocumentURI->GetSpec(url);
if (url.IsEmpty() || NS_FAILED(rv))
return rv;
CopyUTF8toUTF16(url, aURL);
}
return NS_OK;
}
/* readonly attribute DOMString domain; */
NS_IMETHODIMP
nsSVGDocument::GetDomain(nsAString& aDomain)
{
SetDOMStringToNull(aDomain);
if (mDocumentURI) {
nsCAutoString domain;
nsresult rv = mDocumentURI->GetHost(domain);
if (domain.IsEmpty() || NS_FAILED(rv))
return rv;
CopyUTF8toUTF16(domain, aDomain);
}
return NS_OK;
}
nsresult
DOMStorageCache::SetItem(const DOMStorage* aStorage, const nsAString& aKey,
const nsString& aValue, nsString& aOld)
{
if (Persist(aStorage)) {
WaitForPreload(Telemetry::LOCALDOMSTORAGE_SETVALUE_BLOCKING_MS);
if (NS_FAILED(mLoadResult)) {
return mLoadResult;
}
}
Data& data = DataSet(aStorage);
if (!data.mKeys.Get(aKey, &aOld)) {
SetDOMStringToNull(aOld);
}
// Check the quota first
const int64_t delta = static_cast<int64_t>(aValue.Length()) -
static_cast<int64_t>(aOld.Length());
if (!ProcessUsageDelta(aStorage, delta)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
if (aValue == aOld && DOMStringIsNull(aValue) == DOMStringIsNull(aOld)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
data.mKeys.Put(aKey, aValue);
if (Persist(aStorage)) {
if (!sDatabase) {
NS_ERROR("Writing to localStorage after the database has been shut down"
", data lose!");
return NS_ERROR_NOT_INITIALIZED;
}
if (DOMStringIsNull(aOld)) {
return sDatabase->AsyncAddItem(this, aKey, aValue);
}
return sDatabase->AsyncUpdateItem(this, aKey, aValue);
}
return NS_OK;
}
NS_IMETHODIMP
nsDOMOfflineResourceList::MozItem(PRUint32 aIndex, nsAString& aURI)
{
nsresult rv = Init();
NS_ENSURE_SUCCESS(rv, rv);
SetDOMStringToNull(aURI);
rv = CacheKeys();
NS_ENSURE_SUCCESS(rv, rv);
if (aIndex >= mCachedKeysCount)
return NS_ERROR_NOT_AVAILABLE;
CopyUTF8toUTF16(mCachedKeys[aIndex], aURI);
return NS_OK;
}
void
SVGDocument::GetDomain(nsAString& aDomain, ErrorResult& aRv)
{
SetDOMStringToNull(aDomain);
if (mDocumentURI) {
nsAutoCString domain;
nsresult rv = mDocumentURI->GetHost(domain);
if (NS_FAILED(rv)) {
aRv.Throw(rv);
return;
}
if (domain.IsEmpty()) {
return;
}
CopyUTF8toUTF16(domain, aDomain);
}
}
NS_IMETHODIMP
nsXPathNSResolver::LookupNamespaceURI(const nsAString & aPrefix,
nsAString & aResult)
{
if (aPrefix.EqualsLiteral("xml")) {
aResult.AssignLiteral("http://www.w3.org/XML/1998/namespace");
return NS_OK;
}
if (!mNode) {
SetDOMStringToNull(aResult);
return NS_OK;
}
return mNode->LookupNamespaceURI(aPrefix, aResult);
}
FileReader::FileReader(nsPIDOMWindow* aWindow,
WorkerPrivate* aWorkerPrivate)
: DOMEventTargetHelper(aWindow)
, mFileData(nullptr)
, mDataLen(0)
, mDataFormat(FILE_AS_BINARY)
, mResultArrayBuffer(nullptr)
, mProgressEventWasDelayed(false)
, mTimerIsActive(false)
, mReadyState(EMPTY)
, mTotal(0)
, mTransferred(0)
, mTarget(do_GetCurrentThread())
, mBusyCount(0)
, mWorkerPrivate(aWorkerPrivate)
{
MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerPrivate && !aWindow);
MOZ_ASSERT_IF(NS_IsMainThread(), !mWorkerPrivate);
SetDOMStringToNull(mResult);
}
