summaryrefslogtreecommitdiffstats
path: root/dom/storage/StorageIPC.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/storage/StorageIPC.cpp')
-rw-r--r--dom/storage/StorageIPC.cpp1555
1 files changed, 1555 insertions, 0 deletions
diff --git a/dom/storage/StorageIPC.cpp b/dom/storage/StorageIPC.cpp
new file mode 100644
index 0000000000..20aeac427c
--- /dev/null
+++ b/dom/storage/StorageIPC.cpp
@@ -0,0 +1,1555 @@
+/* -*- 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 "StorageIPC.h"
+
+#include "StorageUtils.h"
+#include "LocalStorageManager.h"
+#include "SessionStorageObserver.h"
+#include "SessionStorageManager.h"
+#include "SessionStorageCache.h"
+
+#include "mozilla/dom/LocalStorageCommon.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "mozilla/ipc/PBackgroundParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/Unused.h"
+#include "nsCOMPtr.h"
+#include "nsIPrincipal.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+namespace {
+
+typedef nsClassHashtable<nsCStringHashKey, nsTArray<LocalStorageCacheParent*>>
+ LocalStorageCacheParentHashtable;
+
+StaticAutoPtr<LocalStorageCacheParentHashtable> gLocalStorageCacheParents;
+
+StorageDBChild* sStorageChild[2] = {nullptr, nullptr};
+
+// False until we shut the storage child down.
+bool sStorageChildDown[2] = {false, false};
+
+} // namespace
+
+LocalStorageCacheChild::LocalStorageCacheChild(LocalStorageCache* aCache)
+ : mCache(aCache) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aCache);
+ aCache->AssertIsOnOwningThread();
+
+ MOZ_COUNT_CTOR(LocalStorageCacheChild);
+}
+
+LocalStorageCacheChild::~LocalStorageCacheChild() {
+ AssertIsOnOwningThread();
+
+ MOZ_COUNT_DTOR(LocalStorageCacheChild);
+}
+
+void LocalStorageCacheChild::SendDeleteMeInternal() {
+ AssertIsOnOwningThread();
+
+ if (mCache) {
+ mCache->ClearActor();
+ mCache = nullptr;
+
+ MOZ_ALWAYS_TRUE(PBackgroundLocalStorageCacheChild::SendDeleteMe());
+ }
+}
+
+void LocalStorageCacheChild::ActorDestroy(ActorDestroyReason aWhy) {
+ AssertIsOnOwningThread();
+
+ if (mCache) {
+ mCache->ClearActor();
+ mCache = nullptr;
+ }
+}
+
+mozilla::ipc::IPCResult LocalStorageCacheChild::RecvObserve(
+ const PrincipalInfo& aPrincipalInfo,
+ const PrincipalInfo& aCachePrincipalInfo,
+ const uint32_t& aPrivateBrowsingId, const nsString& aDocumentURI,
+ const nsString& aKey, const nsString& aOldValue,
+ const nsString& aNewValue) {
+ AssertIsOnOwningThread();
+
+ auto principalOrErr = PrincipalInfoToPrincipal(aPrincipalInfo);
+ if (NS_WARN_IF(principalOrErr.isErr())) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ auto cachePrincipalOrErr = PrincipalInfoToPrincipal(aCachePrincipalInfo);
+ if (NS_WARN_IF(cachePrincipalOrErr.isErr())) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
+ nsCOMPtr<nsIPrincipal> cachePrincipal = cachePrincipalOrErr.unwrap();
+
+ if (StorageUtils::PrincipalsEqual(principal, cachePrincipal)) {
+ Storage::NotifyChange(/* aStorage */ nullptr, principal, aKey, aOldValue,
+ aNewValue,
+ /* aStorageType */ u"localStorage", aDocumentURI,
+ /* aIsPrivate */ !!aPrivateBrowsingId,
+ /* aImmediateDispatch */ true);
+ }
+
+ return IPC_OK();
+}
+
+// ----------------------------------------------------------------------------
+// Child
+// ----------------------------------------------------------------------------
+
+class StorageDBChild::ShutdownObserver final : public nsIObserver {
+ // Expected to be only 0 or 1.
+ const uint32_t mPrivateBrowsingId;
+
+ public:
+ explicit ShutdownObserver(const uint32_t aPrivateBrowsingId)
+ : mPrivateBrowsingId(aPrivateBrowsingId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+
+ private:
+ ~ShutdownObserver() { MOZ_ASSERT(NS_IsMainThread()); }
+};
+
+void StorageDBChild::AddIPDLReference() {
+ MOZ_ASSERT(!mIPCOpen, "Attempting to retain multiple IPDL references");
+ mIPCOpen = true;
+ AddRef();
+}
+
+void StorageDBChild::ReleaseIPDLReference() {
+ MOZ_ASSERT(mIPCOpen, "Attempting to release non-existent IPDL reference");
+ mIPCOpen = false;
+ Release();
+}
+
+StorageDBChild::StorageDBChild(LocalStorageManager* aManager,
+ const uint32_t aPrivateBrowsingId)
+ : mManager(aManager),
+ mPrivateBrowsingId(aPrivateBrowsingId),
+ mStatus(NS_OK),
+ mIPCOpen(false) {
+ MOZ_ASSERT(aPrivateBrowsingId <= 1);
+ MOZ_ASSERT(!NextGenLocalStorageEnabled());
+}
+
+StorageDBChild::~StorageDBChild() = default;
+
+// static
+StorageDBChild* StorageDBChild::Get(const uint32_t aPrivateBrowsingId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aPrivateBrowsingId <= 1);
+ MOZ_ASSERT(!NextGenLocalStorageEnabled());
+
+ return sStorageChild[aPrivateBrowsingId];
+}
+
+// static
+StorageDBChild* StorageDBChild::GetOrCreate(const uint32_t aPrivateBrowsingId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aPrivateBrowsingId <= 1);
+ MOZ_ASSERT(!NextGenLocalStorageEnabled());
+
+ StorageDBChild*& storageChild = sStorageChild[aPrivateBrowsingId];
+ if (storageChild || sStorageChildDown[aPrivateBrowsingId]) {
+ // When sStorageChildDown is at true, sStorageChild is null.
+ // Checking sStorageChildDown flag here prevents reinitialization of
+ // the storage child after shutdown.
+ return storageChild;
+ }
+
+ // Use LocalStorageManager::Ensure in case we're called from
+ // DOMSessionStorageManager's initializer and we haven't yet initialized the
+ // local storage manager.
+ RefPtr<StorageDBChild> newStorageChild =
+ new StorageDBChild(LocalStorageManager::Ensure(), aPrivateBrowsingId);
+
+ nsresult rv = newStorageChild->Init();
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return nullptr;
+ }
+
+ newStorageChild.forget(&storageChild);
+
+ return storageChild;
+}
+
+nsTHashtable<nsCStringHashKey>& StorageDBChild::OriginsHavingData() {
+ if (!mOriginsHavingData) {
+ mOriginsHavingData = MakeUnique<nsTHashtable<nsCStringHashKey>>();
+ }
+
+ return *mOriginsHavingData;
+}
+
+nsresult StorageDBChild::Init() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ ::mozilla::ipc::PBackgroundChild* actor =
+ ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
+ if (NS_WARN_IF(!actor)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsString profilePath;
+ if (XRE_IsParentProcess() && mPrivateBrowsingId == 0) {
+ nsresult rv = StorageDBThread::GetProfilePath(profilePath);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ AddIPDLReference();
+
+ actor->SendPBackgroundStorageConstructor(this, profilePath,
+ mPrivateBrowsingId);
+
+ nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();
+ MOZ_ASSERT(observerService);
+
+ nsCOMPtr<nsIObserver> observer = new ShutdownObserver(mPrivateBrowsingId);
+
+ MOZ_ALWAYS_SUCCEEDS(
+ observerService->AddObserver(observer, "xpcom-shutdown", false));
+
+ return NS_OK;
+}
+
+nsresult StorageDBChild::Shutdown() {
+ // There is nothing to do here, IPC will release automatically and
+ // the actual thread running on the parent process will also stop
+ // automatically in profile-before-change topic observer.
+ return NS_OK;
+}
+
+void StorageDBChild::AsyncPreload(LocalStorageCacheBridge* aCache,
+ bool aPriority) {
+ if (mIPCOpen) {
+ // Adding ref to cache for the time of preload. This ensures a reference to
+ // to the cache and that all keys will load into this cache object.
+ mLoadingCaches.PutEntry(aCache);
+ SendAsyncPreload(aCache->OriginSuffix(), aCache->OriginNoSuffix(),
+ aPriority);
+ } else {
+ // No IPC, no love. But the LoadDone call is expected.
+ aCache->LoadDone(NS_ERROR_UNEXPECTED);
+ }
+}
+
+void StorageDBChild::AsyncGetUsage(StorageUsageBridge* aUsage) {
+ if (mIPCOpen) {
+ SendAsyncGetUsage(aUsage->OriginScope());
+ }
+}
+
+void StorageDBChild::SyncPreload(LocalStorageCacheBridge* aCache,
+ bool aForceSync) {
+ if (NS_FAILED(mStatus)) {
+ aCache->LoadDone(mStatus);
+ return;
+ }
+
+ if (!mIPCOpen) {
+ aCache->LoadDone(NS_ERROR_UNEXPECTED);
+ return;
+ }
+
+ // There is no way to put the child process to a wait state to receive all
+ // incoming async responses from the parent, hence we have to do a sync
+ // preload instead. We are smart though, we only demand keys that are left to
+ // load in case the async preload has already loaded some keys.
+ nsTArray<nsString> keys, values;
+ nsresult rv;
+ SendPreload(aCache->OriginSuffix(), aCache->OriginNoSuffix(),
+ aCache->LoadedCount(), &keys, &values, &rv);
+
+ for (uint32_t i = 0; i < keys.Length(); ++i) {
+ aCache->LoadItem(keys[i], values[i]);
+ }
+
+ aCache->LoadDone(rv);
+}
+
+nsresult StorageDBChild::AsyncAddItem(LocalStorageCacheBridge* aCache,
+ const nsAString& aKey,
+ const nsAString& aValue) {
+ if (NS_FAILED(mStatus) || !mIPCOpen) {
+ return mStatus;
+ }
+
+ SendAsyncAddItem(aCache->OriginSuffix(), aCache->OriginNoSuffix(),
+ nsString(aKey), nsString(aValue));
+ OriginsHavingData().PutEntry(aCache->Origin());
+ return NS_OK;
+}
+
+nsresult StorageDBChild::AsyncUpdateItem(LocalStorageCacheBridge* aCache,
+ const nsAString& aKey,
+ const nsAString& aValue) {
+ if (NS_FAILED(mStatus) || !mIPCOpen) {
+ return mStatus;
+ }
+
+ SendAsyncUpdateItem(aCache->OriginSuffix(), aCache->OriginNoSuffix(),
+ nsString(aKey), nsString(aValue));
+ OriginsHavingData().PutEntry(aCache->Origin());
+ return NS_OK;
+}
+
+nsresult StorageDBChild::AsyncRemoveItem(LocalStorageCacheBridge* aCache,
+ const nsAString& aKey) {
+ if (NS_FAILED(mStatus) || !mIPCOpen) {
+ return mStatus;
+ }
+
+ SendAsyncRemoveItem(aCache->OriginSuffix(), aCache->OriginNoSuffix(),
+ nsString(aKey));
+ return NS_OK;
+}
+
+nsresult StorageDBChild::AsyncClear(LocalStorageCacheBridge* aCache) {
+ if (NS_FAILED(mStatus) || !mIPCOpen) {
+ return mStatus;
+ }
+
+ SendAsyncClear(aCache->OriginSuffix(), aCache->OriginNoSuffix());
+ OriginsHavingData().RemoveEntry(aCache->Origin());
+ return NS_OK;
+}
+
+bool StorageDBChild::ShouldPreloadOrigin(const nsACString& aOrigin) {
+ // Return true if we didn't receive the origins list yet.
+ // I tend to rather preserve a bit of early-after-start performance
+ // than a bit of memory here.
+ return !mOriginsHavingData || mOriginsHavingData->Contains(aOrigin);
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvObserve(
+ const nsCString& aTopic, const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope) {
+ MOZ_ASSERT(!XRE_IsParentProcess());
+
+ StorageObserver::Self()->Notify(aTopic.get(), aOriginAttributesPattern,
+ aOriginScope);
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvOriginsHavingData(
+ nsTArray<nsCString>&& aOrigins) {
+ // Force population of mOriginsHavingData even if there are no origins so that
+ // ShouldPreloadOrigin does not generate false positives for all origins.
+ if (!aOrigins.Length()) {
+ Unused << OriginsHavingData();
+ }
+
+ for (uint32_t i = 0; i < aOrigins.Length(); ++i) {
+ OriginsHavingData().PutEntry(aOrigins[i]);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvLoadItem(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const nsString& aKey, const nsString& aValue) {
+ LocalStorageCache* aCache =
+ mManager->GetCache(aOriginSuffix, aOriginNoSuffix);
+ if (aCache) {
+ aCache->LoadItem(aKey, aValue);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvLoadDone(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const nsresult& aRv) {
+ LocalStorageCache* aCache =
+ mManager->GetCache(aOriginSuffix, aOriginNoSuffix);
+ if (aCache) {
+ aCache->LoadDone(aRv);
+
+ // Just drop reference to this cache now since the load is done.
+ mLoadingCaches.RemoveEntry(static_cast<LocalStorageCacheBridge*>(aCache));
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvLoadUsage(
+ const nsCString& aOriginNoSuffix, const int64_t& aUsage) {
+ RefPtr<StorageUsageBridge> scopeUsage =
+ mManager->GetOriginUsage(aOriginNoSuffix, mPrivateBrowsingId);
+ scopeUsage->LoadUsage(aUsage);
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBChild::RecvError(const nsresult& aRv) {
+ mStatus = aRv;
+ return IPC_OK();
+}
+
+NS_IMPL_ISUPPORTS(StorageDBChild::ShutdownObserver, nsIObserver)
+
+NS_IMETHODIMP
+StorageDBChild::ShutdownObserver::Observe(nsISupports* aSubject,
+ const char* aTopic,
+ const char16_t* aData) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!strcmp(aTopic, "xpcom-shutdown"));
+
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+ if (NS_WARN_IF(!observerService)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ Unused << observerService->RemoveObserver(this, "xpcom-shutdown");
+
+ StorageDBChild*& storageChild = sStorageChild[mPrivateBrowsingId];
+ if (storageChild) {
+ sStorageChildDown[mPrivateBrowsingId] = true;
+
+ MOZ_ALWAYS_TRUE(storageChild->PBackgroundStorageChild::SendDeleteMe());
+
+ NS_RELEASE(storageChild);
+ storageChild = nullptr;
+ }
+
+ return NS_OK;
+}
+
+SessionStorageObserverChild::SessionStorageObserverChild(
+ SessionStorageObserver* aObserver)
+ : mObserver(aObserver) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(NextGenLocalStorageEnabled());
+ MOZ_ASSERT(aObserver);
+ aObserver->AssertIsOnOwningThread();
+
+ MOZ_COUNT_CTOR(SessionStorageObserverChild);
+}
+
+SessionStorageObserverChild::~SessionStorageObserverChild() {
+ AssertIsOnOwningThread();
+
+ MOZ_COUNT_DTOR(SessionStorageObserverChild);
+}
+
+void SessionStorageObserverChild::SendDeleteMeInternal() {
+ AssertIsOnOwningThread();
+
+ if (mObserver) {
+ mObserver->ClearActor();
+ mObserver = nullptr;
+
+ // Don't check result here since IPC may no longer be available due to
+ // SessionStorageManager (which holds a strong reference to
+ // SessionStorageObserver) being destroyed very late in the game.
+ PSessionStorageObserverChild::SendDeleteMe();
+ }
+}
+
+void SessionStorageObserverChild::ActorDestroy(ActorDestroyReason aWhy) {
+ AssertIsOnOwningThread();
+
+ if (mObserver) {
+ mObserver->ClearActor();
+ mObserver = nullptr;
+ }
+}
+
+mozilla::ipc::IPCResult SessionStorageObserverChild::RecvObserve(
+ const nsCString& aTopic, const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope) {
+ AssertIsOnOwningThread();
+
+ StorageObserver::Self()->Notify(aTopic.get(), aOriginAttributesPattern,
+ aOriginScope);
+ return IPC_OK();
+}
+
+SessionStorageCacheChild::SessionStorageCacheChild(SessionStorageCache* aCache)
+ : mCache(aCache) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mCache);
+
+ MOZ_COUNT_CTOR(SessionStorageCacheChild);
+}
+
+SessionStorageCacheChild::~SessionStorageCacheChild() {
+ AssertIsOnOwningThread();
+
+ MOZ_COUNT_DTOR(SessionStorageCacheChild);
+}
+
+void SessionStorageCacheChild::SendDeleteMeInternal() {
+ AssertIsOnOwningThread();
+
+ if (mCache) {
+ mCache->ClearActor();
+ mCache = nullptr;
+
+ MOZ_ALWAYS_TRUE(PBackgroundSessionStorageCacheChild::SendDeleteMe());
+ }
+}
+
+void SessionStorageCacheChild::ActorDestroy(ActorDestroyReason aWhy) {
+ AssertIsOnOwningThread();
+
+ if (mCache) {
+ mCache->ClearActor();
+ mCache = nullptr;
+ }
+}
+
+SessionStorageManagerChild::SessionStorageManagerChild(
+ SessionStorageManager* aSSManager)
+ : mSSManager(aSSManager) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mSSManager);
+
+ MOZ_COUNT_CTOR(SessionStorageManagerChild);
+}
+
+SessionStorageManagerChild::~SessionStorageManagerChild() {
+ AssertIsOnOwningThread();
+
+ MOZ_COUNT_DTOR(SessionStorageManagerChild);
+}
+
+void SessionStorageManagerChild::SendDeleteMeInternal() {
+ AssertIsOnOwningThread();
+
+ if (mSSManager) {
+ mSSManager->ClearActor();
+ mSSManager = nullptr;
+
+ MOZ_ALWAYS_TRUE(PBackgroundSessionStorageManagerChild::SendDeleteMe());
+ }
+}
+
+void SessionStorageManagerChild::ActorDestroy(ActorDestroyReason aWhy) {
+ AssertIsOnOwningThread();
+
+ if (mSSManager) {
+ mSSManager->ClearActor();
+ mSSManager = nullptr;
+ }
+}
+
+LocalStorageCacheParent::LocalStorageCacheParent(
+ const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
+ const nsACString& aOriginKey, uint32_t aPrivateBrowsingId)
+ : mPrincipalInfo(aPrincipalInfo),
+ mOriginKey(aOriginKey),
+ mPrivateBrowsingId(aPrivateBrowsingId),
+ mActorDestroyed(false) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+}
+
+LocalStorageCacheParent::~LocalStorageCacheParent() {
+ MOZ_ASSERT(mActorDestroyed);
+}
+
+void LocalStorageCacheParent::ActorDestroy(ActorDestroyReason aWhy) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(!mActorDestroyed);
+
+ mActorDestroyed = true;
+
+ MOZ_ASSERT(gLocalStorageCacheParents);
+
+ nsTArray<LocalStorageCacheParent*>* array;
+ gLocalStorageCacheParents->Get(mOriginKey, &array);
+ MOZ_ASSERT(array);
+
+ array->RemoveElement(this);
+
+ if (array->IsEmpty()) {
+ gLocalStorageCacheParents->Remove(mOriginKey);
+ }
+
+ if (!gLocalStorageCacheParents->Count()) {
+ gLocalStorageCacheParents = nullptr;
+ }
+}
+
+mozilla::ipc::IPCResult LocalStorageCacheParent::RecvDeleteMe() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(!mActorDestroyed);
+
+ IProtocol* mgr = Manager();
+ if (!PBackgroundLocalStorageCacheParent::Send__delete__(this)) {
+ return IPC_FAIL_NO_REASON(mgr);
+ }
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult LocalStorageCacheParent::RecvNotify(
+ const nsString& aDocumentURI, const nsString& aKey,
+ const nsString& aOldValue, const nsString& aNewValue) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(gLocalStorageCacheParents);
+
+ nsTArray<LocalStorageCacheParent*>* array;
+ gLocalStorageCacheParents->Get(mOriginKey, &array);
+ MOZ_ASSERT(array);
+
+ for (LocalStorageCacheParent* localStorageCacheParent : *array) {
+ if (localStorageCacheParent != this) {
+ // When bug 1443925 is fixed, we can compare mPrincipalInfo against
+ // localStorageCacheParent->PrincipalInfo() here on the background thread
+ // instead of posting it to the main thread. The advantage of doing so is
+ // that it would save an IPC message in the case where the principals do
+ // not match.
+ Unused << localStorageCacheParent->SendObserve(
+ mPrincipalInfo, localStorageCacheParent->PrincipalInfo(),
+ mPrivateBrowsingId, aDocumentURI, aKey, aOldValue, aNewValue);
+ }
+ }
+
+ return IPC_OK();
+}
+
+// ----------------------------------------------------------------------------
+// Parent
+// ----------------------------------------------------------------------------
+
+class StorageDBParent::ObserverSink : public StorageObserverSink {
+ nsCOMPtr<nsIEventTarget> mOwningEventTarget;
+
+ // Only touched on the PBackground thread.
+ StorageDBParent* MOZ_NON_OWNING_REF mActor;
+
+ public:
+ explicit ObserverSink(StorageDBParent* aActor)
+ : mOwningEventTarget(GetCurrentEventTarget()), mActor(aActor) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aActor);
+ }
+
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(StorageDBParent::ObserverSink);
+
+ void Start();
+
+ void Stop();
+
+ private:
+ ~ObserverSink() = default;
+
+ void AddSink();
+
+ void RemoveSink();
+
+ void Notify(const nsCString& aTopic, const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope);
+
+ // StorageObserverSink
+ nsresult Observe(const char* aTopic, const nsAString& aOriginAttrPattern,
+ const nsACString& aOriginScope) override;
+};
+
+NS_IMPL_ADDREF(StorageDBParent)
+NS_IMPL_RELEASE(StorageDBParent)
+
+void StorageDBParent::AddIPDLReference() {
+ MOZ_ASSERT(!mIPCOpen, "Attempting to retain multiple IPDL references");
+ mIPCOpen = true;
+ AddRef();
+}
+
+void StorageDBParent::ReleaseIPDLReference() {
+ MOZ_ASSERT(mIPCOpen, "Attempting to release non-existent IPDL reference");
+ mIPCOpen = false;
+ Release();
+}
+
+namespace {} // namespace
+
+StorageDBParent::StorageDBParent(const nsString& aProfilePath,
+ const uint32_t aPrivateBrowsingId)
+ : mProfilePath(aProfilePath),
+ mPrivateBrowsingId(aPrivateBrowsingId),
+ mIPCOpen(false) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ // We are always open by IPC only
+ AddIPDLReference();
+}
+
+StorageDBParent::~StorageDBParent() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ if (mObserverSink) {
+ mObserverSink->Stop();
+ mObserverSink = nullptr;
+ }
+}
+
+void StorageDBParent::Init() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ PBackgroundParent* actor = Manager();
+ MOZ_ASSERT(actor);
+
+ if (::mozilla::ipc::BackgroundParent::IsOtherProcessActor(actor)) {
+ mObserverSink = new ObserverSink(this);
+ mObserverSink->Start();
+ }
+
+ StorageDBThread* storageThread = StorageDBThread::Get(mPrivateBrowsingId);
+ if (storageThread) {
+ nsTArray<nsCString> scopes;
+ storageThread->GetOriginsHavingData(&scopes);
+ mozilla::Unused << SendOriginsHavingData(scopes);
+ }
+}
+
+StorageDBParent::CacheParentBridge* StorageDBParent::NewCache(
+ const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix) {
+ return new CacheParentBridge(this, aOriginSuffix, aOriginNoSuffix);
+}
+
+void StorageDBParent::ActorDestroy(ActorDestroyReason aWhy) {
+ // Implement me! Bug 1005169
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvDeleteMe() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ IProtocol* mgr = Manager();
+ if (!PBackgroundStorageParent::Send__delete__(this)) {
+ return IPC_FAIL_NO_REASON(mgr);
+ }
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncPreload(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const bool& aPriority) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ storageThread->AsyncPreload(NewCache(aOriginSuffix, aOriginNoSuffix),
+ aPriority);
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncGetUsage(
+ const nsCString& aOriginNoSuffix) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ // The object releases it self in LoadUsage method
+ RefPtr<UsageParentBridge> usage =
+ new UsageParentBridge(this, aOriginNoSuffix);
+
+ storageThread->AsyncGetUsage(usage);
+
+ return IPC_OK();
+}
+
+namespace {
+
+// We need another implementation of LocalStorageCacheBridge to do
+// synchronous IPC preload. This class just receives Load* notifications
+// and fills the returning arguments of RecvPreload with the database
+// values for us.
+class SyncLoadCacheHelper : public LocalStorageCacheBridge {
+ public:
+ SyncLoadCacheHelper(const nsCString& aOriginSuffix,
+ const nsCString& aOriginNoSuffix,
+ uint32_t aAlreadyLoadedCount, nsTArray<nsString>* aKeys,
+ nsTArray<nsString>* aValues, nsresult* rv)
+ : mMonitor("DOM Storage SyncLoad IPC"),
+ mSuffix(aOriginSuffix),
+ mOrigin(aOriginNoSuffix),
+ mKeys(aKeys),
+ mValues(aValues),
+ mRv(rv),
+ mLoaded(false),
+ mLoadedCount(aAlreadyLoadedCount) {
+ // Precaution
+ *mRv = NS_ERROR_UNEXPECTED;
+ }
+
+ virtual const nsCString Origin() const override {
+ return LocalStorageManager::CreateOrigin(mSuffix, mOrigin);
+ }
+ virtual const nsCString& OriginNoSuffix() const override { return mOrigin; }
+ virtual const nsCString& OriginSuffix() const override { return mSuffix; }
+ virtual bool Loaded() override { return mLoaded; }
+ virtual uint32_t LoadedCount() override { return mLoadedCount; }
+ virtual bool LoadItem(const nsAString& aKey,
+ const nsString& aValue) override {
+ // Called on the aCache background thread
+ MOZ_ASSERT(!mLoaded);
+ if (mLoaded) {
+ return false;
+ }
+
+ ++mLoadedCount;
+ mKeys->AppendElement(aKey);
+ mValues->AppendElement(aValue);
+ return true;
+ }
+
+ virtual void LoadDone(nsresult aRv) override {
+ // Called on the aCache background thread
+ MonitorAutoLock monitor(mMonitor);
+ MOZ_ASSERT(!mLoaded && mRv);
+ mLoaded = true;
+ if (mRv) {
+ *mRv = aRv;
+ mRv = nullptr;
+ }
+ monitor.Notify();
+ }
+
+ virtual void LoadWait() override {
+ // Called on the main thread, exits after LoadDone() call
+ MonitorAutoLock monitor(mMonitor);
+ while (!mLoaded) {
+ monitor.Wait();
+ }
+ }
+
+ private:
+ Monitor mMonitor;
+ nsCString mSuffix, mOrigin;
+ nsTArray<nsString>* mKeys;
+ nsTArray<nsString>* mValues;
+ nsresult* mRv;
+ bool mLoaded;
+ uint32_t mLoadedCount;
+};
+
+} // namespace
+
+mozilla::ipc::IPCResult StorageDBParent::RecvPreload(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const uint32_t& aAlreadyLoadedCount, nsTArray<nsString>* aKeys,
+ nsTArray<nsString>* aValues, nsresult* aRv) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ RefPtr<SyncLoadCacheHelper> cache(
+ new SyncLoadCacheHelper(aOriginSuffix, aOriginNoSuffix,
+ aAlreadyLoadedCount, aKeys, aValues, aRv));
+
+ storageThread->SyncPreload(cache, true);
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncAddItem(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const nsString& aKey, const nsString& aValue) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ nsresult rv = storageThread->AsyncAddItem(
+ NewCache(aOriginSuffix, aOriginNoSuffix), aKey, aValue);
+ if (NS_FAILED(rv) && mIPCOpen) {
+ mozilla::Unused << SendError(rv);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncUpdateItem(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const nsString& aKey, const nsString& aValue) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ nsresult rv = storageThread->AsyncUpdateItem(
+ NewCache(aOriginSuffix, aOriginNoSuffix), aKey, aValue);
+ if (NS_FAILED(rv) && mIPCOpen) {
+ mozilla::Unused << SendError(rv);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncRemoveItem(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix,
+ const nsString& aKey) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ nsresult rv = storageThread->AsyncRemoveItem(
+ NewCache(aOriginSuffix, aOriginNoSuffix), aKey);
+ if (NS_FAILED(rv) && mIPCOpen) {
+ mozilla::Unused << SendError(rv);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncClear(
+ const nsCString& aOriginSuffix, const nsCString& aOriginNoSuffix) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ nsresult rv =
+ storageThread->AsyncClear(NewCache(aOriginSuffix, aOriginNoSuffix));
+ if (NS_FAILED(rv) && mIPCOpen) {
+ mozilla::Unused << SendError(rv);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvAsyncFlush() {
+ StorageDBThread* storageThread = StorageDBThread::Get(mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ storageThread->AsyncFlush();
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvStartup() {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvClearAll() {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ storageThread->AsyncClearAll();
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvClearMatchingOrigin(
+ const nsCString& aOriginNoSuffix) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ storageThread->AsyncClearMatchingOrigin(aOriginNoSuffix);
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult StorageDBParent::RecvClearMatchingOriginAttributes(
+ const OriginAttributesPattern& aPattern) {
+ StorageDBThread* storageThread =
+ StorageDBThread::GetOrCreate(mProfilePath, mPrivateBrowsingId);
+ if (!storageThread) {
+ return IPC_FAIL_NO_REASON(this);
+ }
+
+ storageThread->AsyncClearMatchingOriginAttributes(aPattern);
+
+ return IPC_OK();
+}
+
+void StorageDBParent::Observe(const nsCString& aTopic,
+ const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope) {
+ if (mIPCOpen) {
+ mozilla::Unused << SendObserve(aTopic, aOriginAttributesPattern,
+ aOriginScope);
+ }
+}
+
+namespace {
+
+// Results must be sent back on the main thread
+class LoadRunnable : public Runnable {
+ public:
+ enum TaskType { loadItem, loadDone };
+
+ LoadRunnable(StorageDBParent* aParent, TaskType aType,
+ const nsACString& aOriginSuffix,
+ const nsACString& aOriginNoSuffix,
+ const nsAString& aKey = u""_ns, const nsAString& aValue = u""_ns)
+ : Runnable("dom::LoadRunnable"),
+ mParent(aParent),
+ mType(aType),
+ mSuffix(aOriginSuffix),
+ mOrigin(aOriginNoSuffix),
+ mKey(aKey),
+ mValue(aValue),
+ mRv(NS_ERROR_NOT_INITIALIZED) {}
+
+ LoadRunnable(StorageDBParent* aParent, TaskType aType,
+ const nsACString& aOriginSuffix,
+ const nsACString& aOriginNoSuffix, nsresult aRv)
+ : Runnable("dom::LoadRunnable"),
+ mParent(aParent),
+ mType(aType),
+ mSuffix(aOriginSuffix),
+ mOrigin(aOriginNoSuffix),
+ mRv(aRv) {}
+
+ private:
+ RefPtr<StorageDBParent> mParent;
+ TaskType mType;
+ nsCString mSuffix, mOrigin;
+ nsString mKey;
+ nsString mValue;
+ nsresult mRv;
+
+ NS_IMETHOD Run() override {
+ if (!mParent->IPCOpen()) {
+ return NS_OK;
+ }
+
+ switch (mType) {
+ case loadItem:
+ mozilla::Unused << mParent->SendLoadItem(mSuffix, mOrigin, mKey,
+ mValue);
+ break;
+ case loadDone:
+ mozilla::Unused << mParent->SendLoadDone(mSuffix, mOrigin, mRv);
+ break;
+ }
+
+ mParent = nullptr;
+
+ return NS_OK;
+ }
+};
+
+} // namespace
+
+// StorageDBParent::CacheParentBridge
+
+const nsCString StorageDBParent::CacheParentBridge::Origin() const {
+ return LocalStorageManager::CreateOrigin(mOriginSuffix, mOriginNoSuffix);
+}
+
+bool StorageDBParent::CacheParentBridge::LoadItem(const nsAString& aKey,
+ const nsString& aValue) {
+ if (mLoaded) {
+ return false;
+ }
+
+ ++mLoadedCount;
+
+ RefPtr<LoadRunnable> r =
+ new LoadRunnable(mParent, LoadRunnable::loadItem, mOriginSuffix,
+ mOriginNoSuffix, aKey, aValue);
+
+ MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(r, NS_DISPATCH_NORMAL));
+
+ return true;
+}
+
+void StorageDBParent::CacheParentBridge::LoadDone(nsresult aRv) {
+ // Prevent send of duplicate LoadDone.
+ if (mLoaded) {
+ return;
+ }
+
+ mLoaded = true;
+
+ RefPtr<LoadRunnable> r = new LoadRunnable(
+ mParent, LoadRunnable::loadDone, mOriginSuffix, mOriginNoSuffix, aRv);
+
+ MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(r, NS_DISPATCH_NORMAL));
+}
+
+void StorageDBParent::CacheParentBridge::LoadWait() {
+ // Should never be called on this implementation
+ MOZ_ASSERT(false);
+}
+
+// XXX Fix me!
+// This should be just:
+// NS_IMPL_RELEASE_WITH_DESTROY(StorageDBParent::CacheParentBridge, Destroy)
+// But due to different strings used for refcount logging and different return
+// types, this is done manually for now.
+NS_IMETHODIMP_(void)
+StorageDBParent::CacheParentBridge::Release(void) {
+ MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
+ nsrefcnt count = --mRefCnt;
+ NS_LOG_RELEASE(this, count, "LocalStorageCacheBridge");
+ if (0 == count) {
+ mRefCnt = 1; /* stabilize */
+ /* enable this to find non-threadsafe destructors: */
+ /* NS_ASSERT_OWNINGTHREAD(_class); */
+ Destroy();
+ }
+}
+
+void StorageDBParent::CacheParentBridge::Destroy() {
+ if (mOwningEventTarget->IsOnCurrentThread()) {
+ delete this;
+ return;
+ }
+
+ RefPtr<Runnable> destroyRunnable = NewNonOwningRunnableMethod(
+ "CacheParentBridge::Destroy", this, &CacheParentBridge::Destroy);
+
+ MOZ_ALWAYS_SUCCEEDS(
+ mOwningEventTarget->Dispatch(destroyRunnable, NS_DISPATCH_NORMAL));
+}
+
+// StorageDBParent::UsageParentBridge
+
+namespace {
+
+class UsageRunnable : public Runnable {
+ public:
+ UsageRunnable(StorageDBParent* aParent, const nsACString& aOriginScope,
+ const int64_t& aUsage)
+ : Runnable("dom::UsageRunnable"),
+ mParent(aParent),
+ mOriginScope(aOriginScope),
+ mUsage(aUsage) {}
+
+ private:
+ NS_IMETHOD Run() override {
+ if (!mParent->IPCOpen()) {
+ return NS_OK;
+ }
+
+ mozilla::Unused << mParent->SendLoadUsage(mOriginScope, mUsage);
+
+ mParent = nullptr;
+
+ return NS_OK;
+ }
+
+ RefPtr<StorageDBParent> mParent;
+ nsCString mOriginScope;
+ int64_t mUsage;
+};
+
+} // namespace
+
+void StorageDBParent::UsageParentBridge::LoadUsage(const int64_t aUsage) {
+ RefPtr<UsageRunnable> r = new UsageRunnable(mParent, mOriginScope, aUsage);
+
+ MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(r, NS_DISPATCH_NORMAL));
+}
+
+// XXX Fix me!
+// This should be just:
+// NS_IMPL_RELEASE_WITH_DESTROY(StorageDBParent::UsageParentBridge, Destroy)
+// But due to different strings used for refcount logging, this is done manually
+// for now.
+NS_IMETHODIMP_(MozExternalRefCountType)
+StorageDBParent::UsageParentBridge::Release(void) {
+ MOZ_ASSERT(int32_t(mRefCnt) > 0, "dup release");
+ nsrefcnt count = --mRefCnt;
+ NS_LOG_RELEASE(this, count, "StorageUsageBridge");
+ if (count == 0) {
+ Destroy();
+ return 0;
+ }
+ return count;
+}
+
+void StorageDBParent::UsageParentBridge::Destroy() {
+ if (mOwningEventTarget->IsOnCurrentThread()) {
+ delete this;
+ return;
+ }
+
+ RefPtr<Runnable> destroyRunnable = NewNonOwningRunnableMethod(
+ "UsageParentBridge::Destroy", this, &UsageParentBridge::Destroy);
+
+ MOZ_ALWAYS_SUCCEEDS(
+ mOwningEventTarget->Dispatch(destroyRunnable, NS_DISPATCH_NORMAL));
+}
+
+void StorageDBParent::ObserverSink::Start() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ RefPtr<Runnable> runnable =
+ NewRunnableMethod("StorageDBParent::ObserverSink::AddSink", this,
+ &StorageDBParent::ObserverSink::AddSink);
+
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
+}
+
+void StorageDBParent::ObserverSink::Stop() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ mActor = nullptr;
+
+ RefPtr<Runnable> runnable =
+ NewRunnableMethod("StorageDBParent::ObserverSink::RemoveSink", this,
+ &StorageDBParent::ObserverSink::RemoveSink);
+
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
+}
+
+void StorageDBParent::ObserverSink::AddSink() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ StorageObserver* observer = StorageObserver::Self();
+ if (observer) {
+ observer->AddSink(this);
+ }
+}
+
+void StorageDBParent::ObserverSink::RemoveSink() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ StorageObserver* observer = StorageObserver::Self();
+ if (observer) {
+ observer->RemoveSink(this);
+ }
+}
+
+void StorageDBParent::ObserverSink::Notify(
+ const nsCString& aTopic, const nsString& aOriginAttributesPattern,
+ const nsCString& aOriginScope) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ if (mActor) {
+ mActor->Observe(aTopic, aOriginAttributesPattern, aOriginScope);
+ }
+}
+
+nsresult StorageDBParent::ObserverSink::Observe(
+ const char* aTopic, const nsAString& aOriginAttributesPattern,
+ const nsACString& aOriginScope) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ RefPtr<Runnable> runnable = NewRunnableMethod<nsCString, nsString, nsCString>(
+ "StorageDBParent::ObserverSink::Observe2", this,
+ &StorageDBParent::ObserverSink::Notify, aTopic, aOriginAttributesPattern,
+ aOriginScope);
+
+ MOZ_ALWAYS_SUCCEEDS(
+ mOwningEventTarget->Dispatch(runnable, NS_DISPATCH_NORMAL));
+
+ return NS_OK;
+}
+
+SessionStorageObserverParent::SessionStorageObserverParent()
+ : mActorDestroyed(false) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ StorageObserver* observer = StorageObserver::Self();
+ if (observer) {
+ observer->AddSink(this);
+ }
+}
+
+SessionStorageObserverParent::~SessionStorageObserverParent() {
+ MOZ_ASSERT(mActorDestroyed);
+
+ StorageObserver* observer = StorageObserver::Self();
+ if (observer) {
+ observer->RemoveSink(this);
+ }
+}
+
+void SessionStorageObserverParent::ActorDestroy(ActorDestroyReason aWhy) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!mActorDestroyed);
+
+ mActorDestroyed = true;
+}
+
+mozilla::ipc::IPCResult SessionStorageObserverParent::RecvDeleteMe() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!mActorDestroyed);
+
+ IProtocol* mgr = Manager();
+ if (!PSessionStorageObserverParent::Send__delete__(this)) {
+ return IPC_FAIL_NO_REASON(mgr);
+ }
+ return IPC_OK();
+}
+
+nsresult SessionStorageObserverParent::Observe(
+ const char* aTopic, const nsAString& aOriginAttributesPattern,
+ const nsACString& aOriginScope) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (!mActorDestroyed) {
+ mozilla::Unused << SendObserve(nsCString(aTopic),
+ nsString(aOriginAttributesPattern),
+ nsCString(aOriginScope));
+ }
+ return NS_OK;
+}
+
+SessionStorageCacheParent::SessionStorageCacheParent(
+ const nsCString& aOriginAttrs, const nsCString& aOriginKey,
+ SessionStorageManagerParent* aActor)
+ : mOriginAttrs(aOriginAttrs),
+ mOriginKey(aOriginKey),
+ mManagerActor(aActor) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mManagerActor);
+}
+
+SessionStorageCacheParent::~SessionStorageCacheParent() = default;
+
+void SessionStorageCacheParent::ActorDestroy(ActorDestroyReason aWhy) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ mManagerActor = nullptr;
+}
+
+mozilla::ipc::IPCResult SessionStorageCacheParent::RecvLoad(
+ nsTArray<SSSetItemInfo>* aDefaultData,
+ nsTArray<SSSetItemInfo>* aSessionData) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mManagerActor);
+
+ mLoadReceived.Flip();
+
+ RefPtr<BackgroundSessionStorageManager> manager = mManagerActor->GetManager();
+ MOZ_ASSERT(manager);
+
+ manager->CopyDataToContentProcess(mOriginAttrs, mOriginKey, *aDefaultData,
+ *aSessionData);
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult SessionStorageCacheParent::RecvCheckpoint(
+ nsTArray<SSWriteInfo>&& aDefaultWriteInfos,
+ nsTArray<SSWriteInfo>&& aSessionWriteInfos) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mManagerActor);
+
+ RefPtr<BackgroundSessionStorageManager> manager = mManagerActor->GetManager();
+ MOZ_ASSERT(manager);
+
+ manager->UpdateData(mOriginAttrs, mOriginKey, aDefaultWriteInfos,
+ aSessionWriteInfos);
+
+ return IPC_OK();
+}
+
+mozilla::ipc::IPCResult SessionStorageCacheParent::RecvDeleteMe() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mManagerActor);
+
+ mManagerActor = nullptr;
+
+ IProtocol* mgr = Manager();
+ if (!PBackgroundSessionStorageCacheParent::Send__delete__(this)) {
+ return IPC_FAIL(
+ mgr, "Failed to delete PBackgroundSessionStorageCacheParent actor");
+ }
+ return IPC_OK();
+}
+
+SessionStorageManagerParent::SessionStorageManagerParent(uint64_t aTopContextId)
+ : mBackgroundManager(
+ BackgroundSessionStorageManager::GetOrCreate(aTopContextId)) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mBackgroundManager);
+}
+
+SessionStorageManagerParent::~SessionStorageManagerParent() = default;
+
+void SessionStorageManagerParent::ActorDestroy(ActorDestroyReason aWhy) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ mBackgroundManager = nullptr;
+}
+
+already_AddRefed<PBackgroundSessionStorageCacheParent>
+SessionStorageManagerParent::AllocPBackgroundSessionStorageCacheParent(
+ const nsCString& aOriginAttrs, const nsCString& aOriginKey) {
+ return MakeAndAddRef<SessionStorageCacheParent>(aOriginAttrs, aOriginKey,
+ this);
+}
+
+BackgroundSessionStorageManager* SessionStorageManagerParent::GetManager()
+ const {
+ return mBackgroundManager;
+}
+
+mozilla::ipc::IPCResult SessionStorageManagerParent::RecvDeleteMe() {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(mBackgroundManager);
+
+ mBackgroundManager = nullptr;
+
+ IProtocol* mgr = Manager();
+ if (!PBackgroundSessionStorageManagerParent::Send__delete__(this)) {
+ return IPC_FAIL(
+ mgr, "Failed to delete PBackgroundSessionStorageManagerParent actor");
+ }
+ return IPC_OK();
+}
+
+/*******************************************************************************
+ * Exported functions
+ ******************************************************************************/
+
+PBackgroundLocalStorageCacheParent* AllocPBackgroundLocalStorageCacheParent(
+ const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
+ const nsCString& aOriginKey, const uint32_t& aPrivateBrowsingId) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ RefPtr<LocalStorageCacheParent> actor = new LocalStorageCacheParent(
+ aPrincipalInfo, aOriginKey, aPrivateBrowsingId);
+
+ // Transfer ownership to IPDL.
+ return actor.forget().take();
+}
+
+mozilla::ipc::IPCResult RecvPBackgroundLocalStorageCacheConstructor(
+ mozilla::ipc::PBackgroundParent* aBackgroundActor,
+ PBackgroundLocalStorageCacheParent* aActor,
+ const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
+ const nsCString& aOriginKey, const uint32_t& aPrivateBrowsingId) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aActor);
+
+ auto* actor = static_cast<LocalStorageCacheParent*>(aActor);
+
+ if (!gLocalStorageCacheParents) {
+ gLocalStorageCacheParents = new LocalStorageCacheParentHashtable();
+ }
+
+ nsTArray<LocalStorageCacheParent*>* array;
+ if (!gLocalStorageCacheParents->Get(aOriginKey, &array)) {
+ array = new nsTArray<LocalStorageCacheParent*>();
+ gLocalStorageCacheParents->Put(aOriginKey, array);
+ }
+ array->AppendElement(actor);
+
+ // We are currently trusting the content process not to lie to us. It is
+ // future work to consult the ClientManager to determine whether this is a
+ // legitimate origin for the content process.
+
+ return IPC_OK();
+}
+
+bool DeallocPBackgroundLocalStorageCacheParent(
+ PBackgroundLocalStorageCacheParent* aActor) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aActor);
+
+ // Transfer ownership back from IPDL.
+ RefPtr<LocalStorageCacheParent> actor =
+ dont_AddRef(static_cast<LocalStorageCacheParent*>(aActor));
+
+ return true;
+}
+
+PBackgroundStorageParent* AllocPBackgroundStorageParent(
+ const nsString& aProfilePath, const uint32_t& aPrivateBrowsingId) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+
+ return new StorageDBParent(aProfilePath, aPrivateBrowsingId);
+}
+
+mozilla::ipc::IPCResult RecvPBackgroundStorageConstructor(
+ PBackgroundStorageParent* aActor, const nsString& aProfilePath,
+ const uint32_t& aPrivateBrowsingId) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aActor);
+
+ auto* actor = static_cast<StorageDBParent*>(aActor);
+ actor->Init();
+ return IPC_OK();
+}
+
+bool DeallocPBackgroundStorageParent(PBackgroundStorageParent* aActor) {
+ ::mozilla::ipc::AssertIsOnBackgroundThread();
+ MOZ_ASSERT(aActor);
+
+ StorageDBParent* actor = static_cast<StorageDBParent*>(aActor);
+ actor->ReleaseIPDLReference();
+ return true;
+}
+
+PSessionStorageObserverParent* AllocPSessionStorageObserverParent() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ RefPtr<SessionStorageObserverParent> actor =
+ new SessionStorageObserverParent();
+
+ // Transfer ownership to IPDL.
+ return actor.forget().take();
+}
+
+bool RecvPSessionStorageObserverConstructor(
+ PSessionStorageObserverParent* aActor) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aActor);
+
+ return true;
+}
+
+bool DeallocPSessionStorageObserverParent(
+ PSessionStorageObserverParent* aActor) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aActor);
+
+ // Transfer ownership back from IPDL.
+ RefPtr<SessionStorageObserverParent> actor =
+ dont_AddRef(static_cast<SessionStorageObserverParent*>(aActor));
+
+ return true;
+}
+
+already_AddRefed<PBackgroundSessionStorageManagerParent>
+AllocPBackgroundSessionStorageManagerParent(const uint64_t& aTopContextId) {
+ return MakeAndAddRef<SessionStorageManagerParent>(aTopContextId);
+}
+
+} // namespace dom
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-29 18:35:28 +0000