gecko-dev/dom/localstorage/ActorsChild.cpp

284 строки
6.8 KiB
C++

/* -*- 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 "ActorsChild.h"
#include "LocalStorageCommon.h"
#include "LSDatabase.h"
#include "LSObject.h"
#include "LSObserver.h"
#include "LSSnapshot.h"
namespace mozilla {
namespace dom {
/*******************************************************************************
* LSDatabaseChild
******************************************************************************/
LSDatabaseChild::LSDatabaseChild(LSDatabase* aDatabase) : mDatabase(aDatabase) {
AssertIsOnOwningThread();
MOZ_ASSERT(aDatabase);
MOZ_COUNT_CTOR(LSDatabaseChild);
}
LSDatabaseChild::~LSDatabaseChild() {
AssertIsOnOwningThread();
MOZ_COUNT_DTOR(LSDatabaseChild);
}
void LSDatabaseChild::SendDeleteMeInternal() {
AssertIsOnOwningThread();
if (mDatabase) {
mDatabase->ClearActor();
mDatabase = nullptr;
MOZ_ALWAYS_TRUE(PBackgroundLSDatabaseChild::SendDeleteMe());
}
}
void LSDatabaseChild::ActorDestroy(ActorDestroyReason aWhy) {
AssertIsOnOwningThread();
if (mDatabase) {
mDatabase->ClearActor();
#ifdef DEBUG
mDatabase = nullptr;
#endif
}
}
mozilla::ipc::IPCResult LSDatabaseChild::RecvRequestAllowToClose() {
AssertIsOnOwningThread();
if (mDatabase) {
mDatabase->RequestAllowToClose();
// TODO: A new datastore will be prepared at first LocalStorage API
// synchronous call. It would be better to start preparing a new
// datastore right here, but asynchronously.
// However, we probably shouldn't do that if we are shutting down.
}
return IPC_OK();
}
PBackgroundLSSnapshotChild* LSDatabaseChild::AllocPBackgroundLSSnapshotChild(
const nsString& aDocumentURI, const bool& aIncreasePeakUsage,
const int64_t& aRequestedSize, const int64_t& aMinSize,
LSSnapshotInitInfo* aInitInfo) {
MOZ_CRASH("PBackgroundLSSnapshotChild actor should be manually constructed!");
}
bool LSDatabaseChild::DeallocPBackgroundLSSnapshotChild(
PBackgroundLSSnapshotChild* aActor) {
MOZ_ASSERT(aActor);
delete aActor;
return true;
}
/*******************************************************************************
* LSObserverChild
******************************************************************************/
LSObserverChild::LSObserverChild(LSObserver* aObserver) : mObserver(aObserver) {
AssertIsOnOwningThread();
MOZ_ASSERT(aObserver);
MOZ_COUNT_CTOR(LSObserverChild);
}
LSObserverChild::~LSObserverChild() {
AssertIsOnOwningThread();
MOZ_COUNT_DTOR(LSObserverChild);
}
void LSObserverChild::SendDeleteMeInternal() {
AssertIsOnOwningThread();
if (mObserver) {
mObserver->ClearActor();
mObserver = nullptr;
MOZ_ALWAYS_TRUE(PBackgroundLSObserverChild::SendDeleteMe());
}
}
void LSObserverChild::ActorDestroy(ActorDestroyReason aWhy) {
AssertIsOnOwningThread();
if (mObserver) {
mObserver->ClearActor();
#ifdef DEBUG
mObserver = nullptr;
#endif
}
}
mozilla::ipc::IPCResult LSObserverChild::RecvObserve(
const PrincipalInfo& aPrincipalInfo, const uint32_t& aPrivateBrowsingId,
const nsString& aDocumentURI, const nsString& aKey,
const nsString& aOldValue, const nsString& aNewValue) {
AssertIsOnOwningThread();
if (!mObserver) {
return IPC_OK();
}
nsresult rv;
nsCOMPtr<nsIPrincipal> principal =
PrincipalInfoToPrincipal(aPrincipalInfo, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return IPC_FAIL_NO_REASON(this);
}
Storage::NotifyChange(/* aStorage */ nullptr, principal, aKey, aOldValue,
aNewValue,
/* aStorageType */ kLocalStorageType, aDocumentURI,
/* aIsPrivate */ !!aPrivateBrowsingId,
/* aImmediateDispatch */ true);
return IPC_OK();
}
/*******************************************************************************
* LocalStorageRequestChild
******************************************************************************/
LSRequestChild::LSRequestChild(LSRequestChildCallback* aCallback)
: mCallback(aCallback), mFinishing(false) {
AssertIsOnOwningThread();
MOZ_COUNT_CTOR(LSRequestChild);
}
LSRequestChild::~LSRequestChild() {
AssertIsOnOwningThread();
MOZ_COUNT_DTOR(LSRequestChild);
}
bool LSRequestChild::Finishing() const {
AssertIsOnOwningThread();
return mFinishing;
}
void LSRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
AssertIsOnOwningThread();
}
mozilla::ipc::IPCResult LSRequestChild::Recv__delete__(
const LSRequestResponse& aResponse) {
AssertIsOnOwningThread();
MOZ_ASSERT(mCallback);
mCallback->OnResponse(aResponse);
return IPC_OK();
}
mozilla::ipc::IPCResult LSRequestChild::RecvReady() {
AssertIsOnOwningThread();
mFinishing = true;
SendFinish();
return IPC_OK();
}
/*******************************************************************************
* LSSimpleRequestChild
******************************************************************************/
LSSimpleRequestChild::LSSimpleRequestChild(
LSSimpleRequestChildCallback* aCallback)
: mCallback(aCallback) {
AssertIsOnOwningThread();
MOZ_ASSERT(aCallback);
MOZ_COUNT_CTOR(LSSimpleRequestChild);
}
LSSimpleRequestChild::~LSSimpleRequestChild() {
AssertIsOnOwningThread();
MOZ_COUNT_DTOR(LSSimpleRequestChild);
}
void LSSimpleRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
AssertIsOnOwningThread();
}
mozilla::ipc::IPCResult LSSimpleRequestChild::Recv__delete__(
const LSSimpleRequestResponse& aResponse) {
AssertIsOnOwningThread();
mCallback->OnResponse(aResponse);
return IPC_OK();
}
/*******************************************************************************
* LSSnapshotChild
******************************************************************************/
LSSnapshotChild::LSSnapshotChild(LSSnapshot* aSnapshot) : mSnapshot(aSnapshot) {
AssertIsOnOwningThread();
MOZ_ASSERT(aSnapshot);
MOZ_COUNT_CTOR(LSSnapshotChild);
}
LSSnapshotChild::~LSSnapshotChild() {
AssertIsOnOwningThread();
MOZ_COUNT_DTOR(LSSnapshotChild);
}
void LSSnapshotChild::SendDeleteMeInternal() {
AssertIsOnOwningThread();
if (mSnapshot) {
mSnapshot->ClearActor();
mSnapshot = nullptr;
MOZ_ALWAYS_TRUE(PBackgroundLSSnapshotChild::SendDeleteMe());
}
}
void LSSnapshotChild::ActorDestroy(ActorDestroyReason aWhy) {
AssertIsOnOwningThread();
if (mSnapshot) {
mSnapshot->ClearActor();
#ifdef DEBUG
mSnapshot = nullptr;
#endif
}
}
mozilla::ipc::IPCResult LSSnapshotChild::RecvMarkDirty() {
AssertIsOnOwningThread();
if (!mSnapshot) {
return IPC_OK();
}
mSnapshot->MarkDirty();
return IPC_OK();
}
} // namespace dom
} // namespace mozilla