Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* 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 "IDBRequest.h"
#include <utility>
#include "BackgroundChildImpl.h"
#include "IDBCursor.h"
#include "IDBDatabase.h"
#include "IDBEvents.h"
#include "IDBFactory.h"
#include "IDBIndex.h"
#include "IDBObjectStore.h"
#include "IDBTransaction.h"
#include "IndexedDatabaseManager.h"
#include "ReportInternalError.h"
#include "mozilla/ContentEvents.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/HoldDropJSObjects.h"
#include "mozilla/dom/DOMException.h"
#include "mozilla/dom/ErrorEventBinding.h"
#include "mozilla/dom/IDBOpenDBRequestBinding.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/WorkerPrivate.h"
#include "mozilla/dom/WorkerRef.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nsIGlobalObject.h"
#include "nsIScriptContext.h"
#include "nsJSUtils.h"
#include "nsString.h"
#include "ThreadLocal.h"
namespace mozilla {
namespace dom {
using namespace mozilla::dom::indexedDB;
using namespace mozilla::ipc;
namespace {
NS_DEFINE_IID(kIDBRequestIID, PRIVATE_IDBREQUEST_IID);
} // namespace
IDBRequest::IDBRequest(IDBDatabase* aDatabase)
: DOMEventTargetHelper(aDatabase),
mLoggingSerialNumber(0),
mLineNo(0),
mColumn(0),
mHaveResultOrErrorCode(false) {
MOZ_ASSERT(aDatabase);
aDatabase->AssertIsOnOwningThread();
InitMembers();
}
IDBRequest::IDBRequest(nsIGlobalObject* aGlobal)
: DOMEventTargetHelper(aGlobal),
mLoggingSerialNumber(0),
mLineNo(0),
mColumn(0),
mHaveResultOrErrorCode(false) {
InitMembers();
}
IDBRequest::~IDBRequest() {
AssertIsOnOwningThread();
mozilla::DropJSObjects(this);
}
void IDBRequest::InitMembers() {
AssertIsOnOwningThread();
mResultVal.setUndefined();
mLoggingSerialNumber = NextSerialNumber();
mErrorCode = NS_OK;
mLineNo = 0;
mColumn = 0;
mHaveResultOrErrorCode = false;
}
// static
MovingNotNull<RefPtr<IDBRequest>> IDBRequest::Create(
JSContext* aCx, IDBDatabase* aDatabase,
SafeRefPtr<IDBTransaction> aTransaction) {
MOZ_ASSERT(aCx);
MOZ_ASSERT(aDatabase);
aDatabase->AssertIsOnOwningThread();
RefPtr<IDBRequest> request = new IDBRequest(aDatabase);
CaptureCaller(aCx, request->mFilename, &request->mLineNo, &request->mColumn);
request->mTransaction = std::move(aTransaction);
return WrapMovingNotNullUnchecked(std::move(request));
}
// static
MovingNotNull<RefPtr<IDBRequest>> IDBRequest::Create(
JSContext* aCx, IDBObjectStore* aSourceAsObjectStore,
IDBDatabase* aDatabase, SafeRefPtr<IDBTransaction> aTransaction) {
MOZ_ASSERT(aSourceAsObjectStore);
aSourceAsObjectStore->AssertIsOnOwningThread();
auto request =
Create(aCx, aDatabase, std::move(aTransaction)).unwrapBasePtr();
request->mSourceAsObjectStore = aSourceAsObjectStore;
return WrapMovingNotNullUnchecked(std::move(request));
}
// static
MovingNotNull<RefPtr<IDBRequest>> IDBRequest::Create(
JSContext* aCx, IDBIndex* aSourceAsIndex, IDBDatabase* aDatabase,
SafeRefPtr<IDBTransaction> aTransaction) {
MOZ_ASSERT(aSourceAsIndex);
aSourceAsIndex->AssertIsOnOwningThread();
auto request =
Create(aCx, aDatabase, std::move(aTransaction)).unwrapBasePtr();
request->mSourceAsIndex = aSourceAsIndex;
return WrapMovingNotNullUnchecked(std::move(request));
}
// static
uint64_t IDBRequest::NextSerialNumber() {
BackgroundChildImpl::ThreadLocal* threadLocal =
BackgroundChildImpl::GetThreadLocalForCurrentThread();
MOZ_ASSERT(threadLocal);
const auto& idbThreadLocal = threadLocal->mIndexedDBThreadLocal;
MOZ_ASSERT(idbThreadLocal);
return idbThreadLocal->NextRequestSN();
}
void IDBRequest::SetLoggingSerialNumber(uint64_t aLoggingSerialNumber) {
AssertIsOnOwningThread();
MOZ_ASSERT(aLoggingSerialNumber > mLoggingSerialNumber);
mLoggingSerialNumber = aLoggingSerialNumber;
}
void IDBRequest::CaptureCaller(JSContext* aCx, nsAString& aFilename,
uint32_t* aLineNo, uint32_t* aColumn) {
MOZ_ASSERT(aFilename.IsEmpty());
MOZ_ASSERT(aLineNo);
MOZ_ASSERT(aColumn);
nsJSUtils::GetCallingLocation(aCx, aFilename, aLineNo, aColumn);
}
void IDBRequest::GetSource(
Nullable<OwningIDBObjectStoreOrIDBIndexOrIDBCursor>& aSource) const {
AssertIsOnOwningThread();
MOZ_ASSERT_IF(mSourceAsObjectStore, !mSourceAsIndex);
MOZ_ASSERT_IF(mSourceAsIndex, !mSourceAsObjectStore);
MOZ_ASSERT_IF(mSourceAsCursor, mSourceAsObjectStore || mSourceAsIndex);
// Always check cursor first since cursor requests hold both the cursor and
// the objectStore or index the cursor came from.
if (mSourceAsCursor) {
aSource.SetValue().SetAsIDBCursor() = mSourceAsCursor;
} else if (mSourceAsObjectStore) {
aSource.SetValue().SetAsIDBObjectStore() = mSourceAsObjectStore;
} else if (mSourceAsIndex) {
aSource.SetValue().SetAsIDBIndex() = mSourceAsIndex;
} else {
aSource.SetNull();
}
}
void IDBRequest::Reset() {
AssertIsOnOwningThread();
mResultVal.setUndefined();
mHaveResultOrErrorCode = false;
mError = nullptr;
}
void IDBRequest::SetError(nsresult aRv) {
AssertIsOnOwningThread();
MOZ_ASSERT(NS_FAILED(aRv));
MOZ_ASSERT(NS_ERROR_GET_MODULE(aRv) == NS_ERROR_MODULE_DOM_INDEXEDDB);
MOZ_ASSERT(!mError);
mHaveResultOrErrorCode = true;
mError = DOMException::Create(aRv);
mErrorCode = aRv;
mResultVal.setUndefined();
}
#ifdef DEBUG
nsresult IDBRequest::GetErrorCode() const {
AssertIsOnOwningThread();
MOZ_ASSERT(mHaveResultOrErrorCode);
return mErrorCode;
}
DOMException* IDBRequest::GetErrorAfterResult() const {
AssertIsOnOwningThread();
MOZ_ASSERT(mHaveResultOrErrorCode);
return mError;
}
#endif // DEBUG
void IDBRequest::GetCallerLocation(nsAString& aFilename, uint32_t* aLineNo,
uint32_t* aColumn) const {
AssertIsOnOwningThread();
MOZ_ASSERT(aLineNo);
MOZ_ASSERT(aColumn);
aFilename = mFilename;
*aLineNo = mLineNo;
*aColumn = mColumn;
}
IDBRequestReadyState IDBRequest::ReadyState() const {
AssertIsOnOwningThread();
return IsPending() ? IDBRequestReadyState::Pending
: IDBRequestReadyState::Done;
}
void IDBRequest::SetSource(IDBCursor* aSource) {
AssertIsOnOwningThread();
MOZ_ASSERT(aSource);
MOZ_ASSERT(mSourceAsObjectStore || mSourceAsIndex);
MOZ_ASSERT(!mSourceAsCursor);
mSourceAsCursor = aSource;
}
JSObject* IDBRequest::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) {
return IDBRequest_Binding::Wrap(aCx, this, aGivenProto);
}
void IDBRequest::GetResult(JS::MutableHandle<JS::Value> aResult,
ErrorResult& aRv) const {
AssertIsOnOwningThread();
if (!mHaveResultOrErrorCode) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
aResult.set(mResultVal);
}
DOMException* IDBRequest::GetError(ErrorResult& aRv) {
AssertIsOnOwningThread();
if (!mHaveResultOrErrorCode) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
return mError;
}
NS_IMPL_CYCLE_COLLECTION_MULTI_ZONE_JSHOLDER_CLASS(IDBRequest)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBRequest,
DOMEventTargetHelper)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourceAsObjectStore)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourceAsIndex)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSourceAsCursor)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTransaction)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mError)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBRequest,
DOMEventTargetHelper)
tmp->mResultVal.setUndefined();
mozilla::DropJSObjects(tmp);
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSourceAsObjectStore)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSourceAsIndex)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSourceAsCursor)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mTransaction)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mError)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(IDBRequest, DOMEventTargetHelper)
// Don't need NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER because
// DOMEventTargetHelper does it for us.
NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(mResultVal)
NS_IMPL_CYCLE_COLLECTION_TRACE_END
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IDBRequest)
if (aIID.Equals(kIDBRequestIID)) {
foundInterface = this;
} else
NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
NS_IMPL_ADDREF_INHERITED(IDBRequest, DOMEventTargetHelper)
NS_IMPL_RELEASE_INHERITED(IDBRequest, DOMEventTargetHelper)
void IDBRequest::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
AssertIsOnOwningThread();
aVisitor.mCanHandle = true;
aVisitor.SetParentTarget(mTransaction.unsafeGetRawPtr(), false);
}
IDBOpenDBRequest::IDBOpenDBRequest(SafeRefPtr<IDBFactory> aFactory,
nsIGlobalObject* aGlobal,
bool aFileHandleDisabled)
: IDBRequest(aGlobal),
mFactory(std::move(aFactory)),
mFileHandleDisabled(aFileHandleDisabled),
mIncreasedActiveDatabaseCount(false) {
AssertIsOnOwningThread();
MOZ_ASSERT(mFactory);
MOZ_ASSERT(aGlobal);
}
IDBOpenDBRequest::~IDBOpenDBRequest() {
AssertIsOnOwningThread();
MOZ_ASSERT(!mIncreasedActiveDatabaseCount);
}
// static
RefPtr<IDBOpenDBRequest> IDBOpenDBRequest::Create(
JSContext* aCx, SafeRefPtr<IDBFactory> aFactory, nsIGlobalObject* aGlobal) {
MOZ_ASSERT(aFactory);
aFactory->AssertIsOnOwningThread();
MOZ_ASSERT(aGlobal);
bool fileHandleDisabled = !IndexedDatabaseManager::IsFileHandleEnabled();
RefPtr<IDBOpenDBRequest> request =
new IDBOpenDBRequest(std::move(aFactory), aGlobal, fileHandleDisabled);
CaptureCaller(aCx, request->mFilename, &request->mLineNo, &request->mColumn);
if (!NS_IsMainThread()) {
WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
MOZ_ASSERT(workerPrivate);
workerPrivate->AssertIsOnWorkerThread();
request->mWorkerRef =
StrongWorkerRef::Create(workerPrivate, "IDBOpenDBRequest");
if (NS_WARN_IF(!request->mWorkerRef)) {
return nullptr;
}
}
request->IncreaseActiveDatabaseCount();
return request;
}
void IDBOpenDBRequest::SetTransaction(SafeRefPtr<IDBTransaction> aTransaction) {
AssertIsOnOwningThread();
MOZ_ASSERT(!aTransaction || !mTransaction);
mTransaction = std::move(aTransaction);
}
void IDBOpenDBRequest::DispatchNonTransactionError(nsresult aErrorCode) {
AssertIsOnOwningThread();
MOZ_ASSERT(NS_FAILED(aErrorCode));
MOZ_ASSERT(NS_ERROR_GET_MODULE(aErrorCode) == NS_ERROR_MODULE_DOM_INDEXEDDB);
// The actor failed to initiate, decrease the number of active IDBOpenRequests
// here since NoteComplete won't be called.
MaybeDecreaseActiveDatabaseCount();
SetError(aErrorCode);
// Make an error event and fire it at the target.
auto event = CreateGenericEvent(this, nsDependentString(kErrorEventType),
eDoesBubble, eCancelable);
IgnoredErrorResult rv;
DispatchEvent(*event, rv);
if (rv.Failed()) {
NS_WARNING("Failed to dispatch event!");
}
}
void IDBOpenDBRequest::NoteComplete() {
AssertIsOnOwningThread();
MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerRef);
// Normally, we decrease the number of active IDBOpenRequests here.
MaybeDecreaseActiveDatabaseCount();
// If we have a WorkerRef, then nulling this out will release the worker.
mWorkerRef = nullptr;
}
void IDBOpenDBRequest::IncreaseActiveDatabaseCount() {
AssertIsOnOwningThread();
MOZ_ASSERT(!mIncreasedActiveDatabaseCount);
// Increase the number of active IDBOpenRequests.
// Note: We count here instead of the actor's ctor because the preemption
// could happen at next JS interrupt but its BackgroundFactoryRequestChild
// could be created asynchronously from IDBFactory::BackgroundCreateCallback
// ::ActorCreated() if its PBackgroundChild is not created yet on this thread.
mFactory->UpdateActiveDatabaseCount(1);
mIncreasedActiveDatabaseCount = true;
}
void IDBOpenDBRequest::MaybeDecreaseActiveDatabaseCount() {
AssertIsOnOwningThread();
if (mIncreasedActiveDatabaseCount) {
// Decrease the number of active IDBOpenRequests.
mFactory->UpdateActiveDatabaseCount(-1);
mIncreasedActiveDatabaseCount = false;
}
}
NS_IMPL_CYCLE_COLLECTION_CLASS(IDBOpenDBRequest)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBOpenDBRequest, IDBRequest)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFactory)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBOpenDBRequest, IDBRequest)
// Don't unlink mFactory!
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(IDBOpenDBRequest)
NS_INTERFACE_MAP_END_INHERITING(IDBRequest)
NS_IMPL_ADDREF_INHERITED(IDBOpenDBRequest, IDBRequest)
NS_IMPL_RELEASE_INHERITED(IDBOpenDBRequest, IDBRequest)
nsresult IDBOpenDBRequest::PostHandleEvent(EventChainPostVisitor& aVisitor) {
nsresult rv =
IndexedDatabaseManager::CommonPostHandleEvent(aVisitor, *mFactory);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
JSObject* IDBOpenDBRequest::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) {
AssertIsOnOwningThread();
return IDBOpenDBRequest_Binding::Wrap(aCx, this, aGivenProto);
}
} // namespace dom
} // namespace mozilla