mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-11 16:32:59 +00:00
136 lines
3.4 KiB
C++
136 lines
3.4 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 "mozilla/dom/cache/OfflineStorage.h"
|
|
|
|
#include "mozilla/dom/cache/Context.h"
|
|
#include "mozilla/dom/cache/QuotaClient.h"
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
|
#include "nsThreadUtils.h"
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
namespace cache {
|
|
|
|
using mozilla::dom::quota::Client;
|
|
using mozilla::dom::quota::PERSISTENCE_TYPE_DEFAULT;
|
|
using mozilla::dom::quota::QuotaManager;
|
|
|
|
NS_IMPL_ISUPPORTS(OfflineStorage, nsIOfflineStorage);
|
|
|
|
// static
|
|
already_AddRefed<OfflineStorage>
|
|
OfflineStorage::Register(Context::ThreadsafeHandle* aContext,
|
|
const QuotaInfo& aQuotaInfo)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
QuotaManager* qm = QuotaManager::Get();
|
|
if (NS_WARN_IF(!qm)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsRefPtr<Client> client = qm->GetClient(Client::DOMCACHE);
|
|
|
|
nsRefPtr<OfflineStorage> storage =
|
|
new OfflineStorage(aContext, aQuotaInfo, client);
|
|
|
|
if (NS_WARN_IF(!qm->RegisterStorage(storage))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return storage.forget();
|
|
}
|
|
|
|
void
|
|
OfflineStorage::AddDestroyCallback(nsIRunnable* aCallback)
|
|
{
|
|
MOZ_ASSERT(aCallback);
|
|
MOZ_ASSERT(!mDestroyCallbacks.Contains(aCallback));
|
|
mDestroyCallbacks.AppendElement(aCallback);
|
|
}
|
|
|
|
OfflineStorage::OfflineStorage(Context::ThreadsafeHandle* aContext,
|
|
const QuotaInfo& aQuotaInfo,
|
|
Client* aClient)
|
|
: mContext(aContext)
|
|
, mQuotaInfo(aQuotaInfo)
|
|
, mClient(aClient)
|
|
{
|
|
MOZ_ASSERT(mContext);
|
|
MOZ_ASSERT(mClient);
|
|
|
|
mPersistenceType = PERSISTENCE_TYPE_DEFAULT;
|
|
mGroup = mQuotaInfo.mGroup;
|
|
}
|
|
|
|
OfflineStorage::~OfflineStorage()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
QuotaManager* qm = QuotaManager::Get();
|
|
MOZ_ASSERT(qm);
|
|
qm->UnregisterStorage(this);
|
|
for (uint32_t i = 0; i < mDestroyCallbacks.Length(); ++i) {
|
|
mDestroyCallbacks[i]->Run();
|
|
}
|
|
}
|
|
|
|
NS_IMETHODIMP_(const nsACString&)
|
|
OfflineStorage::Id()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return mQuotaInfo.mStorageId;
|
|
}
|
|
|
|
NS_IMETHODIMP_(Client*)
|
|
OfflineStorage::GetClient()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return mClient;
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
OfflineStorage::IsOwnedByProcess(ContentParent* aOwner)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
// The Cache and Context can be shared by multiple client processes. They
|
|
// are not exclusively owned by a single process.
|
|
//
|
|
// As far as I can tell this is used by QuotaManager to shutdown storages
|
|
// when a particular process goes away. We definitely don't want this
|
|
// since we are shared. Also, the Cache actor code already properly
|
|
// handles asynchronous actor destruction when the child process dies.
|
|
//
|
|
// Therefore, always return false here.
|
|
return false;
|
|
}
|
|
|
|
NS_IMETHODIMP_(const nsACString&)
|
|
OfflineStorage::Origin()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
return mQuotaInfo.mOrigin;
|
|
}
|
|
|
|
NS_IMETHODIMP_(nsresult)
|
|
OfflineStorage::Close()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
mContext->AllowToClose();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP_(void)
|
|
OfflineStorage::Invalidate()
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
mContext->InvalidateAndAllowToClose();
|
|
}
|
|
|
|
} // namespace cache
|
|
} // namespace dom
|
|
} // namespace mozilla
|