NS_IMETHODIMP
FinishHelper::Run()
{
if (NS_IsMainThread()) {
mLockedFile->mReadyState = LockedFile::DONE;
FileService* service = FileService::Get();
if (service) {
service->NotifyLockedFileCompleted(mLockedFile);
}
nsCOMPtr<nsIDOMEvent> event;
if (mAborted) {
event = CreateGenericEvent(NS_LITERAL_STRING("abort"), true, false);
}
else {
event = CreateGenericEvent(NS_LITERAL_STRING("complete"), false, false);
}
NS_ENSURE_TRUE(event, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
bool dummy;
if (NS_FAILED(mLockedFile->DispatchEvent(event, &dummy))) {
NS_WARNING("Dispatch failed!");
}
mLockedFile = nullptr;
return NS_OK;
}
nsIFileStorage* fileStorage = mLockedFile->mFileHandle->mFileStorage;
if (fileStorage->IsStorageInvalidated()) {
mAborted = true;
}
for (uint32_t index = 0; index < mParallelStreams.Length(); index++) {
nsCOMPtr<nsIOutputStream> ostream =
do_QueryInterface(mParallelStreams[index]);
if (NS_FAILED(ostream->Close())) {
NS_WARNING("Failed to close stream!");
}
mParallelStreams[index] = nullptr;
}
if (mStream) {
nsCOMPtr<nsIOutputStream> ostream = do_QueryInterface(mStream);
if (NS_FAILED(ostream->Close())) {
NS_WARNING("Failed to close stream!");
}
mStream = nullptr;
}
return NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL);
}
void
IDBTransaction::FireCompleteOrAbortEvents(nsresult aResult)
{
AssertIsOnOwningThread();
MOZ_ASSERT(!mFiredCompleteOrAbort);
mReadyState = DONE;
#ifdef DEBUG
mFiredCompleteOrAbort = true;
#endif
// Make sure we drop the WorkerFeature when this function completes.
nsAutoPtr<WorkerFeature> workerFeature = Move(mWorkerFeature);
nsCOMPtr<nsIDOMEvent> event;
if (NS_SUCCEEDED(aResult)) {
event = CreateGenericEvent(this,
nsDependentString(kCompleteEventType),
eDoesNotBubble,
eNotCancelable);
MOZ_ASSERT(event);
} else {
if (!mError && !mAbortedByScript) {
mError = new DOMError(GetOwner(), aResult);
}
event = CreateGenericEvent(this,
nsDependentString(kAbortEventType),
eDoesBubble,
eNotCancelable);
MOZ_ASSERT(event);
}
if (NS_SUCCEEDED(mAbortCode)) {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld]: "
"Firing 'complete' event",
"IndexedDB %s: C T[%lld]: IDBTransaction 'complete' event",
IDB_LOG_ID_STRING(),
mLoggingSerialNumber);
} else {
IDB_LOG_MARK("IndexedDB %s: Child Transaction[%lld]: "
"Firing 'abort' event with error 0x%x",
"IndexedDB %s: C T[%lld]: IDBTransaction 'abort' event (0x%x)",
IDB_LOG_ID_STRING(),
mLoggingSerialNumber,
mAbortCode);
}
bool dummy;
if (NS_FAILED(DispatchEvent(event, &dummy))) {
NS_WARNING("DispatchEvent failed!");
}
mDatabase->DelayedMaybeExpireFileActors();
}
void
AsyncConnectionHelper::OnError()
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(mRequest, "Null request!");
// Make an error event and fire it at the target.
nsRefPtr<nsDOMEvent> event =
CreateGenericEvent(NS_LITERAL_STRING(ERROR_EVT_STR), eDoesBubble,
eCancelable);
if (!event) {
NS_ERROR("Failed to create event!");
return;
}
bool doDefault;
nsresult rv = mRequest->DispatchEvent(event, &doDefault);
if (NS_SUCCEEDED(rv)) {
NS_ASSERTION(!mTransaction ||
mTransaction->IsOpen() ||
mTransaction->IsAborted(),
"How else can this be closed?!");
if (doDefault &&
mTransaction &&
mTransaction->IsOpen() &&
NS_FAILED(mTransaction->Abort())) {
NS_WARNING("Failed to abort transaction!");
}
}
else {
NS_WARNING("DispatchEvent failed!");
}
}
nsresult
IDBDatabase::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
{
NS_ENSURE_TRUE(aVisitor.mDOMEvent, NS_ERROR_UNEXPECTED);
if (!mOwner) {
return NS_OK;
}
if (aVisitor.mEventStatus != nsEventStatus_eConsumeNoDefault) {
nsString type;
nsresult rv = aVisitor.mDOMEvent->GetType(type);
NS_ENSURE_SUCCESS(rv, rv);
if (type.EqualsLiteral(ERROR_EVT_STR)) {
nsRefPtr<nsDOMEvent> duplicateEvent =
CreateGenericEvent(type, eDoesNotBubble, eNotCancelable);
NS_ENSURE_STATE(duplicateEvent);
nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(mOwner));
NS_ASSERTION(target, "How can this happen?!");
bool dummy;
rv = target->DispatchEvent(duplicateEvent, &dummy);
NS_ENSURE_SUCCESS(rv, rv);
}
}
return NS_OK;
}
already_AddRefed<nsIRunnable>
mozilla::dom::indexedDB::CreateGenericEventRunnable(const nsAString& aType,
nsIDOMEventTarget* aTarget)
{
nsCOMPtr<nsIDOMEvent> event(CreateGenericEvent(aType));
NS_ENSURE_TRUE(event, nsnull);
nsCOMPtr<nsIRunnable> runnable(new EventFiringRunnable(aTarget, event));
return runnable.forget();
}
nsresult
IDBFileHandle::OnCompleteOrAbort(bool aAborted)
{
nsCOMPtr<nsIDOMEvent> event;
if (aAborted) {
event = CreateGenericEvent(this, NS_LITERAL_STRING(ABORT_EVT_STR),
eDoesBubble, eNotCancelable);
} else {
event = CreateGenericEvent(this, NS_LITERAL_STRING(COMPLETE_EVT_STR),
eDoesNotBubble, eNotCancelable);
}
if (NS_WARN_IF(!event)) {
return NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR;
}
bool dummy;
if (NS_FAILED(DispatchEvent(event, &dummy))) {
NS_WARNING("Dispatch failed!");
}
return NS_OK;
}
nsresult
IDBFileHandle::OnCompleteOrAbort(bool aAborted)
{
nsCOMPtr<nsIDOMEvent> event;
if (aAborted) {
event = CreateGenericEvent(this, nsDependentString(kAbortEventType),
eDoesBubble, eNotCancelable);
} else {
event = CreateGenericEvent(this, nsDependentString(kCompleteEventType),
eDoesNotBubble, eNotCancelable);
}
if (NS_WARN_IF(!event)) {
return NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR;
}
bool dummy;
if (NS_FAILED(DispatchEvent(event, &dummy))) {
NS_WARNING("Dispatch failed!");
}
return NS_OK;
}
void
OpenDatabaseHelper::DispatchSuccessEvent()
{
NS_ASSERTION(mDatabase, "Doesn't seem very successful to me.");
nsRefPtr<nsDOMEvent> event =
CreateGenericEvent(NS_LITERAL_STRING(SUCCESS_EVT_STR));
if (!event) {
NS_ERROR("Failed to create event!");
return;
}
bool dummy;
mOpenDBRequest->DispatchEvent(event, &dummy);
}
void
IDBFileHandle::HandleCompleteOrAbort(bool aAborted)
{
AssertIsOnOwningThread();
FileHandleBase::HandleCompleteOrAbort(aAborted);
nsCOMPtr<nsIDOMEvent> event;
if (aAborted) {
event = CreateGenericEvent(this, nsDependentString(kAbortEventType),
eDoesBubble, eNotCancelable);
} else {
event = CreateGenericEvent(this, nsDependentString(kCompleteEventType),
eDoesNotBubble, eNotCancelable);
}
if (NS_WARN_IF(!event)) {
return;
}
bool dummy;
if (NS_FAILED(DispatchEvent(event, &dummy))) {
NS_WARNING("DispatchEvent failed!");
}
}
void
OpenDatabaseHelper::DispatchErrorEvent()
{
nsRefPtr<nsDOMEvent> event =
CreateGenericEvent(NS_LITERAL_STRING(ERROR_EVT_STR));
if (!event) {
NS_ERROR("Failed to create event!");
return;
}
PRUint16 errorCode = 0;
DebugOnly<nsresult> rv =
mOpenDBRequest->GetErrorCode(&errorCode);
NS_ASSERTION(NS_SUCCEEDED(rv), "This shouldn't be failing at this point!");
if (!errorCode) {
mOpenDBRequest->SetError(mResultCode);
}
bool dummy;
mOpenDBRequest->DispatchEvent(event, &dummy);
}
void
IDBRequest::DispatchNonTransactionError(nsresult aErrorCode)
{
AssertIsOnOwningThread();
MOZ_ASSERT(NS_FAILED(aErrorCode));
MOZ_ASSERT(NS_ERROR_GET_MODULE(aErrorCode) == NS_ERROR_MODULE_DOM_INDEXEDDB);
SetError(aErrorCode);
// Make an error event and fire it at the target.
nsCOMPtr<nsIDOMEvent> event =
CreateGenericEvent(this,
nsDependentString(kErrorEventType),
eDoesBubble,
eCancelable);
MOZ_ASSERT(event);
bool ignored;
if (NS_FAILED(DispatchEvent(event, &ignored))) {
NS_WARNING("Failed to dispatch event!");
}
}
already_AddRefed<nsDOMEvent>
AsyncConnectionHelper::CreateSuccessEvent()
{
return CreateGenericEvent(NS_LITERAL_STRING(SUCCESS_EVT_STR),
eDoesNotBubble, eNotCancelable);
}
