void
InternalResponse::ToIPC(IPCInternalResponse* aIPCResponse,
M* aManager,
UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoStream)
{
MOZ_ASSERT(aIPCResponse);
aIPCResponse->type() = mType;
aIPCResponse->urlList() = mURLList;
aIPCResponse->status() = GetUnfilteredStatus();
aIPCResponse->statusText() = GetUnfilteredStatusText();
mHeaders->ToIPC(aIPCResponse->headers(), aIPCResponse->headersGuard());
aIPCResponse->channelInfo() = mChannelInfo.AsIPCChannelInfo();
if (mPrincipalInfo) {
aIPCResponse->principalInfo() = *mPrincipalInfo;
} else {
aIPCResponse->principalInfo() = void_t();
}
nsCOMPtr<nsIInputStream> body;
int64_t bodySize;
GetUnfilteredBody(getter_AddRefs(body), &bodySize);
if (body) {
aAutoStream.reset(new mozilla::ipc::AutoIPCStream(aIPCResponse->body()));
DebugOnly<bool> ok = aAutoStream->Serialize(body, aManager);
MOZ_ASSERT(ok);
} else {
aIPCResponse->body() = void_t();
}
aIPCResponse->bodySize() = bodySize;
}
void
AutoChildOpArgs::Add(JSContext* aCx, InternalRequest* aRequest,
BodyAction aBodyAction, SchemeAction aSchemeAction,
Response& aResponse, ErrorResult& aRv)
{
MOZ_DIAGNOSTIC_ASSERT(!mSent);
switch(mOpArgs.type()) {
case CacheOpArgs::TCachePutAllArgs:
{
CachePutAllArgs& args = mOpArgs.get_CachePutAllArgs();
// Throw an error if a request/response pair would mask another
// request/response pair in the same PutAll operation. This is
// step 2.3.2.3 from the "Batch Cache Operations" spec algorithm.
if (MatchInPutList(aRequest, args.requestResponseList())) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
// Ensure that we don't realloc the array since this can result
// in our AutoIPCStream objects to reference the wrong memory
// location. This should never happen and is a UAF if it does.
// Therefore make this a release assertion.
MOZ_RELEASE_ASSERT(args.requestResponseList().Length() <
args.requestResponseList().Capacity());
// The FileDescriptorSetChild asserts in its destructor that all fds have
// been removed. The copy constructor, however, simply duplicates the
// fds without removing any. This means each temporary and copy must be
// explicitly cleaned up.
//
// Avoid a lot of this hassle by making sure we only create one here. On
// error we remove it.
CacheRequestResponse& pair = *args.requestResponseList().AppendElement();
pair.request().body() = void_t();
pair.response().body() = void_t();
mTypeUtils->ToCacheRequest(pair.request(), aRequest, aBodyAction,
aSchemeAction, mStreamCleanupList, aRv);
if (!aRv.Failed()) {
mTypeUtils->ToCacheResponse(aCx, pair.response(), aResponse,
mStreamCleanupList, aRv);
}
if (aRv.Failed()) {
CleanupChild(pair.request().body(), Delete);
args.requestResponseList().RemoveElementAt(
args.requestResponseList().Length() - 1);
}
break;
}
default:
MOZ_CRASH("Cache args type cannot send a Request/Response pair!");
}
}
JSONVariant
MakeTestVariant(HandleT* handle)
{
// In JS syntax:
//
// return [
// undefined, null, true, 1.25, "test string",
// handle,
// [ 1, 2, 3 ],
// { "undefined" : undefined,
// "null" : null,
// "true" : true,
// "1.25" : 1.25,
// "string" : "string"
// "handle" : handle,
// "array" : [ 1, 2, 3 ]
// }
// ]
//
InfallibleTArray<JSONVariant> outer;
outer.AppendElement(void_t());
outer.AppendElement(null_t());
outer.AppendElement(true);
outer.AppendElement(1.25);
outer.AppendElement(String("test string"));
outer.AppendElement(handle);
InfallibleTArray<JSONVariant> tmp;
Array123(tmp);
outer.AppendElement(tmp);
InfallibleTArray<KeyValue> obj;
obj.AppendElement(KeyValue(String("undefined"), void_t()));
obj.AppendElement(KeyValue(String("null"), null_t()));
obj.AppendElement(KeyValue(String("true"), true));
obj.AppendElement(KeyValue(String("1.25"), 1.25));
obj.AppendElement(KeyValue(String("string"), String("value")));
obj.AppendElement(KeyValue(String("handle"), handle));
InfallibleTArray<JSONVariant> tmp2;
Array123(tmp2);
obj.AppendElement(KeyValue(String("array"), tmp2));
outer.AppendElement(obj);
test_assert(outer == outer, "operator== is broken");
return JSONVariant(outer);
}
nsresult
LoadInfoToLoadInfoArgs(nsILoadInfo *aLoadInfo,
OptionalLoadInfoArgs* aOptionalLoadInfoArgs)
{
if (!aLoadInfo) {
// if there is no loadInfo, then there is nothing to serialize
*aOptionalLoadInfoArgs = void_t();
return NS_OK;
}
nsresult rv = NS_OK;
PrincipalInfo requestingPrincipalInfo;
rv = PrincipalToPrincipalInfo(aLoadInfo->LoadingPrincipal(),
&requestingPrincipalInfo);
NS_ENSURE_SUCCESS(rv, rv);
PrincipalInfo triggeringPrincipalInfo;
rv = PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
&triggeringPrincipalInfo);
*aOptionalLoadInfoArgs =
LoadInfoArgs(
requestingPrincipalInfo,
triggeringPrincipalInfo,
aLoadInfo->GetSecurityFlags(),
aLoadInfo->GetContentPolicyType(),
aLoadInfo->GetUpgradeInsecureRequests(),
aLoadInfo->GetInnerWindowID(),
aLoadInfo->GetOuterWindowID(),
aLoadInfo->GetParentOuterWindowID());
return NS_OK;
}
void
NotifyAlarmFired()
{
if (sAlarmObserver) {
sAlarmObserver->Notify(void_t());
}
}
void
AutoParentOpResult::Add(const SavedRequest& aSavedRequest,
StreamList* aStreamList)
{
MOZ_DIAGNOSTIC_ASSERT(!mSent);
switch (mOpResult.type()) {
case CacheOpResult::TCacheKeysResult:
{
CacheKeysResult& result = mOpResult.get_CacheKeysResult();
// Ensure that we don't realloc the array since this can result
// in our AutoIPCStream objects to reference the wrong memory
// location. This should never happen and is a UAF if it does.
// Therefore make this a release assertion.
MOZ_RELEASE_ASSERT(result.requestList().Length() <
result.requestList().Capacity());
result.requestList().AppendElement(aSavedRequest.mValue);
CacheRequest& request = result.requestList().LastElement();
if (!aSavedRequest.mHasBodyId) {
request.body() = void_t();
break;
}
request.body() = CacheReadStream();
SerializeReadStream(aSavedRequest.mBodyId, aStreamList,
&request.body().get_CacheReadStream());
break;
}
default:
MOZ_CRASH("Cache result type cannot handle returning a Request!");
}
}
already_AddRefed<Promise>
Cache::Keys(JSContext* aCx, const Optional<RequestOrUSVString>& aRequest,
const CacheQueryOptions& aOptions, ErrorResult& aRv)
{
if (NS_WARN_IF(!mActor)) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
CacheChild::AutoLock actorLock(mActor);
CacheQueryParams params;
ToCacheQueryParams(params, aOptions);
AutoChildOpArgs args(this,
CacheKeysArgs(void_t(), params, GetOpenMode()),
1);
if (aRequest.WasPassed()) {
RefPtr<InternalRequest> ir =
ToInternalRequest(aCx, aRequest.Value(), IgnoreBody, aRv);
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
args.Add(ir, IgnoreBody, IgnoreInvalidScheme, aRv);
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
}
return ExecuteOp(args, aRv);
}
nsresult
SerializeInternal(BlobImpl* aBlobImpl, M* aManager, IPCBlob& aIPCBlob)
{
MOZ_ASSERT(aBlobImpl);
nsAutoString value;
aBlobImpl->GetType(value);
aIPCBlob.type() = value;
ErrorResult rv;
aIPCBlob.size() = aBlobImpl->GetSize(rv);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
if (!aBlobImpl->IsFile()) {
aIPCBlob.file() = void_t();
} else {
IPCFile file;
aBlobImpl->GetName(value);
file.name() = value;
file.lastModified() = aBlobImpl->GetLastModified(rv) * PR_USEC_PER_MSEC;
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
aBlobImpl->GetDOMPath(value);
file.DOMPath() = value;
aBlobImpl->GetMozFullPathInternal(value, rv);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
file.fullPath() = value;
file.isDirectory() = aBlobImpl->IsDirectory();
aIPCBlob.file() = file;
}
aIPCBlob.fileId() = aBlobImpl->GetFileId();
nsCOMPtr<nsIInputStream> inputStream;
aBlobImpl->CreateInputStream(getter_AddRefs(inputStream), rv);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
rv = SerializeInputStream(inputStream, aIPCBlob.size(),
ChildIDFromManager(aManager), aIPCBlob, aManager);
if (NS_WARN_IF(rv.Failed())) {
return rv.StealNSResult();
}
return NS_OK;
}
already_AddRefed<IDBRequest>
IDBIndex::Count(JSContext* aCx,
JS::Handle<JS::Value> aKey,
ErrorResult& aRv)
{
AssertIsOnOwningThread();
if (mDeletedMetadata) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
return nullptr;
}
IDBTransaction* transaction = mObjectStore->Transaction();
if (!transaction->IsOpen()) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
return nullptr;
}
RefPtr<IDBKeyRange> keyRange;
aRv = IDBKeyRange::FromJSVal(aCx, aKey, getter_AddRefs(keyRange));
if (aRv.Failed()) {
return nullptr;
}
IndexCountParams params;
params.objectStoreId() = mObjectStore->Id();
params.indexId() = Id();
if (keyRange) {
SerializedKeyRange serializedKeyRange;
keyRange->ToSerialized(serializedKeyRange);
params.optionalKeyRange() = serializedKeyRange;
} else {
params.optionalKeyRange() = void_t();
}
RefPtr<IDBRequest> request = GenerateRequest(this);
MOZ_ASSERT(request);
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"count(%s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBObjectStore.count()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange));
transaction->StartRequest(request, params);
return request.forget();
}
nsresult
LoadInfoToLoadInfoArgs(nsILoadInfo *aLoadInfo,
OptionalLoadInfoArgs* aOptionalLoadInfoArgs)
{
if (!aLoadInfo) {
// if there is no loadInfo, then there is nothing to serialize
*aOptionalLoadInfoArgs = void_t();
return NS_OK;
}
nsresult rv = NS_OK;
PrincipalInfo requestingPrincipalInfo;
rv = PrincipalToPrincipalInfo(aLoadInfo->LoadingPrincipal(),
&requestingPrincipalInfo);
NS_ENSURE_SUCCESS(rv, rv);
PrincipalInfo triggeringPrincipalInfo;
rv = PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
&triggeringPrincipalInfo);
nsTArray<PrincipalInfo> redirectChainIncludingInternalRedirects;
for (const nsCOMPtr<nsIPrincipal>& principal : aLoadInfo->RedirectChainIncludingInternalRedirects()) {
rv = PrincipalToPrincipalInfo(principal, redirectChainIncludingInternalRedirects.AppendElement());
NS_ENSURE_SUCCESS(rv, rv);
}
nsTArray<PrincipalInfo> redirectChain;
for (const nsCOMPtr<nsIPrincipal>& principal : aLoadInfo->RedirectChain()) {
rv = PrincipalToPrincipalInfo(principal, redirectChain.AppendElement());
NS_ENSURE_SUCCESS(rv, rv);
}
*aOptionalLoadInfoArgs =
LoadInfoArgs(
requestingPrincipalInfo,
triggeringPrincipalInfo,
aLoadInfo->GetSecurityFlags(),
aLoadInfo->InternalContentPolicyType(),
aLoadInfo->GetUpgradeInsecureRequests(),
aLoadInfo->GetUpgradeInsecurePreloads(),
aLoadInfo->GetInnerWindowID(),
aLoadInfo->GetOuterWindowID(),
aLoadInfo->GetParentOuterWindowID(),
aLoadInfo->GetEnforceSecurity(),
aLoadInfo->GetInitialSecurityCheckDone(),
aLoadInfo->GetIsInThirdPartyContext(),
aLoadInfo->GetOriginAttributes(),
redirectChainIncludingInternalRedirects,
redirectChain);
return NS_OK;
}
NS_IMETHODIMP
SmsRequestParent::NotifySendMessageFailed(int32_t aError, nsISupports *aMessage)
{
NS_ENSURE_TRUE(!mActorDestroyed, NS_ERROR_FAILURE);
ContentParent *parent = static_cast<ContentParent*>(Manager()->Manager());
MobileMessageData data;
if (!GetMobileMessageDataFromMessage(parent, aMessage, data)) {
return SendReply(ReplyMessageSendFail(aError, OptionalMobileMessageData(void_t())));
}
return SendReply(ReplyMessageSendFail(aError, OptionalMobileMessageData(data)));
}
void
AutoParentOpResult::SerializeResponseBody(const SavedResponse& aSavedResponse,
StreamList* aStreamList,
CacheResponse* aResponseOut)
{
MOZ_DIAGNOSTIC_ASSERT(aResponseOut);
if (!aSavedResponse.mHasBodyId) {
aResponseOut->body() = void_t();
return;
}
aResponseOut->body() = CacheReadStream();
SerializeReadStream(aSavedResponse.mBodyId, aStreamList,
&aResponseOut->body().get_CacheReadStream());
}
NS_IMETHODIMP
IccParent::NotifyIccInfoChanged()
{
NS_ENSURE_TRUE(mIcc, NS_ERROR_FAILURE);
nsCOMPtr<nsIIccInfo> iccInfo;
nsresult rv = mIcc->GetIccInfo(getter_AddRefs(iccInfo));
NS_ENSURE_SUCCESS(rv, rv);
if (!iccInfo) {
return SendNotifyIccInfoChanged(OptionalIccInfoData(void_t()))
? NS_OK : NS_ERROR_FAILURE;
}
IccInfoData data;
IccIPCUtils::GetIccInfoDataFromIccInfo(iccInfo, data);
return SendNotifyIccInfoChanged(OptionalIccInfoData(data))
? NS_OK : NS_ERROR_FAILURE;
}
nsresult
LoadInfoToLoadInfoArgs(nsILoadInfo *aLoadInfo,
OptionalLoadInfoArgs* aOptionalLoadInfoArgs)
{
if (!aLoadInfo) {
// if there is no loadInfo, then there is nothing to serialize
*aOptionalLoadInfoArgs = void_t();
return NS_OK;
}
nsresult rv = NS_OK;
OptionalPrincipalInfo loadingPrincipalInfo = mozilla::void_t();
if (aLoadInfo->LoadingPrincipal()) {
PrincipalInfo loadingPrincipalInfoTemp;
rv = PrincipalToPrincipalInfo(aLoadInfo->LoadingPrincipal(),
&loadingPrincipalInfoTemp);
NS_ENSURE_SUCCESS(rv, rv);
loadingPrincipalInfo = loadingPrincipalInfoTemp;
}
PrincipalInfo triggeringPrincipalInfo;
rv = PrincipalToPrincipalInfo(aLoadInfo->TriggeringPrincipal(),
&triggeringPrincipalInfo);
nsTArray<PrincipalInfo> redirectChainIncludingInternalRedirects;
for (const nsCOMPtr<nsIPrincipal>& principal : aLoadInfo->RedirectChainIncludingInternalRedirects()) {
rv = PrincipalToPrincipalInfo(principal, redirectChainIncludingInternalRedirects.AppendElement());
NS_ENSURE_SUCCESS(rv, rv);
}
nsTArray<PrincipalInfo> redirectChain;
for (const nsCOMPtr<nsIPrincipal>& principal : aLoadInfo->RedirectChain()) {
rv = PrincipalToPrincipalInfo(principal, redirectChain.AppendElement());
NS_ENSURE_SUCCESS(rv, rv);
}
*aOptionalLoadInfoArgs =
LoadInfoArgs(
loadingPrincipalInfo,
triggeringPrincipalInfo,
aLoadInfo->GetSecurityFlags(),
aLoadInfo->InternalContentPolicyType(),
static_cast<uint32_t>(aLoadInfo->GetTainting()),
aLoadInfo->GetUpgradeInsecureRequests(),
aLoadInfo->GetVerifySignedContent(),
aLoadInfo->GetEnforceSRI(),
aLoadInfo->GetForceInheritPrincipalDropped(),
aLoadInfo->GetInnerWindowID(),
aLoadInfo->GetOuterWindowID(),
aLoadInfo->GetParentOuterWindowID(),
aLoadInfo->GetFrameOuterWindowID(),
aLoadInfo->GetEnforceSecurity(),
aLoadInfo->GetInitialSecurityCheckDone(),
aLoadInfo->GetIsInThirdPartyContext(),
aLoadInfo->GetOriginAttributes(),
redirectChainIncludingInternalRedirects,
redirectChain,
aLoadInfo->CorsUnsafeHeaders(),
aLoadInfo->GetForcePreflight(),
aLoadInfo->GetIsPreflight());
return NS_OK;
}
already_AddRefed<IDBRequest>
IDBIndex::OpenCursorInternal(bool aKeysOnly,
JSContext* aCx,
JS::Handle<JS::Value> aRange,
IDBCursorDirection aDirection,
ErrorResult& aRv)
{
AssertIsOnOwningThread();
if (mDeletedMetadata) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
return nullptr;
}
IDBTransaction* transaction = mObjectStore->Transaction();
if (!transaction->IsOpen()) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
return nullptr;
}
RefPtr<IDBKeyRange> keyRange;
aRv = IDBKeyRange::FromJSVal(aCx, aRange, getter_AddRefs(keyRange));
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
int64_t objectStoreId = mObjectStore->Id();
int64_t indexId = Id();
OptionalKeyRange optionalKeyRange;
if (keyRange) {
SerializedKeyRange serializedKeyRange;
keyRange->ToSerialized(serializedKeyRange);
optionalKeyRange = Move(serializedKeyRange);
} else {
optionalKeyRange = void_t();
}
IDBCursor::Direction direction = IDBCursor::ConvertDirection(aDirection);
OpenCursorParams params;
if (aKeysOnly) {
IndexOpenKeyCursorParams openParams;
openParams.objectStoreId() = objectStoreId;
openParams.indexId() = indexId;
openParams.optionalKeyRange() = Move(optionalKeyRange);
openParams.direction() = direction;
params = Move(openParams);
} else {
IndexOpenCursorParams openParams;
openParams.objectStoreId() = objectStoreId;
openParams.indexId() = indexId;
openParams.optionalKeyRange() = Move(optionalKeyRange);
openParams.direction() = direction;
params = Move(openParams);
}
RefPtr<IDBRequest> request = GenerateRequest(this);
MOZ_ASSERT(request);
if (aKeysOnly) {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"openKeyCursor(%s, %s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBIndex.openKeyCursor()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange),
IDB_LOG_STRINGIFY(direction));
} else {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"openCursor(%s, %s)",
"IndexedDB %s: C T[%lld] R[%llu]: "
"IDBObjectStore.openKeyCursor()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange),
IDB_LOG_STRINGIFY(direction));
}
BackgroundCursorChild* actor =
new BackgroundCursorChild(request, this, direction);
mObjectStore->Transaction()->OpenCursor(actor, params);
return request.forget();
}
already_AddRefed<IDBRequest>
IDBIndex::GetAllInternal(bool aKeysOnly,
JSContext* aCx,
JS::Handle<JS::Value> aKey,
const Optional<uint32_t>& aLimit,
ErrorResult& aRv)
{
AssertIsOnOwningThread();
if (mDeletedMetadata) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR);
return nullptr;
}
IDBTransaction* transaction = mObjectStore->Transaction();
if (!transaction->IsOpen()) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
return nullptr;
}
RefPtr<IDBKeyRange> keyRange;
aRv = IDBKeyRange::FromJSVal(aCx, aKey, getter_AddRefs(keyRange));
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
const int64_t objectStoreId = mObjectStore->Id();
const int64_t indexId = Id();
OptionalKeyRange optionalKeyRange;
if (keyRange) {
SerializedKeyRange serializedKeyRange;
keyRange->ToSerialized(serializedKeyRange);
optionalKeyRange = serializedKeyRange;
} else {
optionalKeyRange = void_t();
}
const uint32_t limit = aLimit.WasPassed() ? aLimit.Value() : 0;
RequestParams params;
if (aKeysOnly) {
params = IndexGetAllKeysParams(objectStoreId, indexId, optionalKeyRange,
limit);
} else {
params = IndexGetAllParams(objectStoreId, indexId, optionalKeyRange, limit);
}
RefPtr<IDBRequest> request = GenerateRequest(this);
MOZ_ASSERT(request);
if (aKeysOnly) {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"getAllKeys(%s, %s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBIndex.getAllKeys()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange),
IDB_LOG_STRINGIFY(aLimit));
} else {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"getAll(%s, %s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBIndex.getAll()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange),
IDB_LOG_STRINGIFY(aLimit));
}
transaction->StartRequest(request, params);
return request.forget();
}
already_AddRefed<IDBRequest>
IDBIndex::GetInternal(bool aKeyOnly,
JSContext* aCx,
JS::Handle<JS::Value> aKey,
ErrorResult& aRv)
{
AssertIsOnOwningThread();
IDBTransaction* transaction = mObjectStore->Transaction();
if (!transaction->IsOpen()) {
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_TRANSACTION_INACTIVE_ERR);
return nullptr;
}
nsRefPtr<IDBKeyRange> keyRange;
aRv = IDBKeyRange::FromJSVal(aCx, aKey, getter_AddRefs(keyRange));
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
if (!keyRange) {
// Must specify a key or keyRange for get() and getKey().
aRv.Throw(NS_ERROR_DOM_INDEXEDDB_DATA_ERR);
return nullptr;
}
const int64_t objectStoreId = mObjectStore->Id();
const int64_t indexId = Id();
OptionalKeyRange optionalKeyRange;
if (keyRange) {
SerializedKeyRange serializedKeyRange;
keyRange->ToSerialized(serializedKeyRange);
optionalKeyRange = serializedKeyRange;
} else {
optionalKeyRange = void_t();
}
RequestParams params;
if (aKeyOnly) {
params = IndexGetKeyParams(objectStoreId, indexId, optionalKeyRange);
} else {
params = IndexGetParams(objectStoreId, indexId, optionalKeyRange);
}
nsRefPtr<IDBRequest> request = GenerateRequest(this);
MOZ_ASSERT(request);
if (aKeyOnly) {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"getKey(%s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBIndex.getKey()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange));
} else {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld] Request[%llu]: "
"database(%s).transaction(%s).objectStore(%s).index(%s)."
"get(%s)",
"IndexedDB %s: C T[%lld] R[%llu]: IDBIndex.get()",
IDB_LOG_ID_STRING(),
transaction->LoggingSerialNumber(),
request->LoggingSerialNumber(),
IDB_LOG_STRINGIFY(transaction->Database()),
IDB_LOG_STRINGIFY(transaction),
IDB_LOG_STRINGIFY(mObjectStore),
IDB_LOG_STRINGIFY(this),
IDB_LOG_STRINGIFY(keyRange));
}
transaction->StartRequest(request, params);
return request.forget();
}
