corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1322316 - Split SessionStorage and LocalStorage implementation - part 11 - SessionStorageCache must have 2 DataSet: default and sessionOnly, r=asuth

Browse Source
This commit is contained in:
Andrea Marchesini
2017-05-17 07:01:15 +02:00
parent 61562c66b1
commit 1ecbbef470
5 changed files with 149 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
dom/storage/SessionStorage.cpp
View File

@@ -14,6 +14,10 @@
#include "nsIPrincipal.h"
#include "nsPIDOMWindow.h"
#define DATASET IsSessionOnly() \
? SessionStorageCache::eSessionSetType \
: SessionStorageCache::eDefaultSetType
namespace mozilla {
namespace dom {
@@ -56,7 +60,7 @@ SessionStorage::Clone() const
int64_t
SessionStorage::GetOriginQuotaUsage() const
{
return mCache->GetOriginQuotaUsage();
return mCache->GetOriginQuotaUsage(DATASET);
}
uint32_t
@@ -68,7 +72,7 @@ SessionStorage::GetLength(nsIPrincipal& aSubjectPrincipal,
return 0;
}
return mCache->Length();
return mCache->Length(DATASET);
}
void
@@ -81,7 +85,7 @@ SessionStorage::Key(uint32_t aIndex, nsAString& aResult,
return;
}
mCache->Key(aIndex, aResult);
mCache->Key(DATASET, aIndex, aResult);
}
void
@@ -94,7 +98,7 @@ SessionStorage::GetItem(const nsAString& aKey, nsAString& aResult,
return;
}
mCache->GetItem(aKey, aResult);
mCache->GetItem(DATASET, aKey, aResult);
}
void
@@ -106,7 +110,7 @@ SessionStorage::GetSupportedNames(nsTArray<nsString>& aKeys)
return;
}
mCache->GetKeys(aKeys);
mCache->GetKeys(DATASET, aKeys);
}
void
@@ -120,7 +124,7 @@ SessionStorage::SetItem(const nsAString& aKey, const nsAString& aValue,
}
nsString oldValue;
nsresult rv = mCache->SetItem(aKey, aValue, oldValue);
nsresult rv = mCache->SetItem(DATASET, aKey, aValue, oldValue);
if (NS_WARN_IF(NS_FAILED(rv))) {
aRv.Throw(rv);
return;
@@ -144,7 +148,7 @@ SessionStorage::RemoveItem(const nsAString& aKey,
}
nsString oldValue;
nsresult rv = mCache->RemoveItem(aKey, oldValue);
nsresult rv = mCache->RemoveItem(DATASET, aKey, oldValue);
MOZ_ASSERT(NS_SUCCEEDED(rv));
if (rv == NS_SUCCESS_DOM_NO_OPERATION) {
@@ -163,7 +167,7 @@ SessionStorage::Clear(nsIPrincipal& aSubjectPrincipal,
return;
}
mCache->Clear();
mCache->Clear(DATASET);
BroadcastChangeNotification(NullString(), NullString(), NullString());
}

118
dom/storage/SessionStorageCache.cpp
View File

@@ -10,14 +10,49 @@ namespace mozilla {
namespace dom {
SessionStorageCache::SessionStorageCache()
: mOriginQuotaUsage(0)
: mSessionDataSetActive(false)
{}
SessionStorageCache::DataSet*
SessionStorageCache::Set(DataSetType aDataSetType)
{
if (aDataSetType == eDefaultSetType) {
return &mDefaultSet;
}
MOZ_ASSERT(aDataSetType == eSessionSetType);
if (!mSessionDataSetActive) {
mSessionSet.mOriginQuotaUsage = mDefaultSet.mOriginQuotaUsage;
for (auto iter = mDefaultSet.mKeys.ConstIter(); !iter.Done(); iter.Next()) {
mSessionSet.mKeys.Put(iter.Key(), iter.Data());
}
mSessionDataSetActive = true;
}
return &mSessionSet;
}
int64_t
SessionStorageCache::GetOriginQuotaUsage(DataSetType aDataSetType)
{
return Set(aDataSetType)->mOriginQuotaUsage;
}
uint32_t
SessionStorageCache::Length(DataSetType aDataSetType)
{
return Set(aDataSetType)->mKeys.Count();
}
void
SessionStorageCache::Key(uint32_t aIndex, nsAString& aResult)
SessionStorageCache::Key(DataSetType aDataSetType, uint32_t aIndex,
nsAString& aResult)
{
aResult.SetIsVoid(true);
for (auto iter = mKeys.Iter(); !iter.Done(); iter.Next()) {
for (auto iter = Set(aDataSetType)->mKeys.Iter(); !iter.Done(); iter.Next()) {
if (aIndex == 0) {
aResult = iter.Key();
return;
@@ -27,31 +62,33 @@ SessionStorageCache::Key(uint32_t aIndex, nsAString& aResult)
}
void
SessionStorageCache::GetItem(const nsAString& aKey, nsAString& aResult)
SessionStorageCache::GetItem(DataSetType aDataSetType, const nsAString& aKey,
nsAString& aResult)
{
// not using AutoString since we don't want to copy buffer to result
nsString value;
if (!mKeys.Get(aKey, &value)) {
if (!Set(aDataSetType)->mKeys.Get(aKey, &value)) {
SetDOMStringToNull(value);
}
aResult = value;
}
void
SessionStorageCache::GetKeys(nsTArray<nsString>& aKeys)
SessionStorageCache::GetKeys(DataSetType aDataSetType, nsTArray<nsString>& aKeys)
{
for (auto iter = mKeys.Iter(); !iter.Done(); iter.Next()) {
for (auto iter = Set(aDataSetType)->mKeys.Iter(); !iter.Done(); iter.Next()) {
aKeys.AppendElement(iter.Key());
}
}
nsresult
SessionStorageCache::SetItem(const nsAString& aKey, const nsAString& aValue,
nsString& aOldValue)
SessionStorageCache::SetItem(DataSetType aDataSetType, const nsAString& aKey,
const nsAString& aValue, nsString& aOldValue)
{
int64_t delta = 0;
DataSet* dataSet = Set(aDataSetType);
if (!mKeys.Get(aKey, &aOldValue)) {
if (!dataSet->mKeys.Get(aKey, &aOldValue)) {
SetDOMStringToNull(aOldValue);
// We only consider key size if the key doesn't exist before.
@@ -66,38 +103,66 @@ SessionStorageCache::SetItem(const nsAString& aKey, const nsAString& aValue,
return NS_SUCCESS_DOM_NO_OPERATION;
}
if (!ProcessUsageDelta(delta)) {
if (!dataSet->ProcessUsageDelta(delta)) {
return NS_ERROR_DOM_QUOTA_REACHED;
}
mKeys.Put(aKey, nsString(aValue));
dataSet->mKeys.Put(aKey, nsString(aValue));
return NS_OK;
}
nsresult
SessionStorageCache::RemoveItem(const nsAString& aKey, nsString& aOldValue)
SessionStorageCache::RemoveItem(DataSetType aDataSetType, const nsAString& aKey,
nsString& aOldValue)
{
if (!mKeys.Get(aKey, &aOldValue)) {
DataSet* dataSet = Set(aDataSetType);
if (!dataSet->mKeys.Get(aKey, &aOldValue)) {
return NS_SUCCESS_DOM_NO_OPERATION;
}
// Recalculate the cached data size
ProcessUsageDelta(-(static_cast<int64_t>(aOldValue.Length()) +
dataSet->ProcessUsageDelta(-(static_cast<int64_t>(aOldValue.Length()) +
static_cast<int64_t>(aKey.Length())));
mKeys.Remove(aKey);
dataSet->mKeys.Remove(aKey);
return NS_OK;
}
void
SessionStorageCache::Clear()
SessionStorageCache::Clear(DataSetType aDataSetType, bool aByUserInteraction)
{
ProcessUsageDelta(-mOriginQuotaUsage);
mKeys.Clear();
DataSet* dataSet = Set(aDataSetType);
dataSet->ProcessUsageDelta(-dataSet->mOriginQuotaUsage);
dataSet->mKeys.Clear();
if (!aByUserInteraction && aDataSetType == eSessionSetType) {
mSessionDataSetActive = false;
}
}
already_AddRefed<SessionStorageCache>
SessionStorageCache::Clone() const
{
RefPtr<SessionStorageCache> cache = new SessionStorageCache();
cache->mSessionDataSetActive = mSessionDataSetActive;
cache->mDefaultSet.mOriginQuotaUsage = mDefaultSet.mOriginQuotaUsage;
for (auto iter = mDefaultSet.mKeys.ConstIter(); !iter.Done(); iter.Next()) {
cache->mDefaultSet.mKeys.Put(iter.Key(), iter.Data());
}
cache->mSessionSet.mOriginQuotaUsage = mSessionSet.mOriginQuotaUsage;
for (auto iter = mSessionSet.mKeys.ConstIter(); !iter.Done(); iter.Next()) {
cache->mSessionSet.mKeys.Put(iter.Key(), iter.Data());
}
return cache.forget();
}
bool
SessionStorageCache::ProcessUsageDelta(int64_t aDelta)
SessionStorageCache::DataSet::ProcessUsageDelta(int64_t aDelta)
{
// Check limit per this origin
uint64_t newOriginUsage = mOriginQuotaUsage + aDelta;
@@ -110,18 +175,5 @@ SessionStorageCache::ProcessUsageDelta(int64_t aDelta)
return true;
}
already_AddRefed<SessionStorageCache>
SessionStorageCache::Clone() const
{
RefPtr<SessionStorageCache> cache = new SessionStorageCache();
cache->mOriginQuotaUsage = mOriginQuotaUsage;
for (auto iter = mKeys.ConstIter(); !iter.Done(); iter.Next()) {
cache->mKeys.Put(iter.Key(), iter.Data());
}
return cache.forget();
}
} // dom namespace
} // mozilla namespace

42
dom/storage/SessionStorageCache.h
View File

@@ -19,26 +19,29 @@ public:
SessionStorageCache();
int64_t GetOriginQuotaUsage() const
{
return mOriginQuotaUsage;
}
enum DataSetType {
eDefaultSetType,
eSessionSetType,
};
uint32_t Length() const { return mKeys.Count(); }
int64_t GetOriginQuotaUsage(DataSetType aDataSetType);
void Key(uint32_t aIndex, nsAString& aResult);
uint32_t Length(DataSetType aDataSetType);
void GetItem(const nsAString& aKey, nsAString& aResult);
void Key(DataSetType aDataSetType, uint32_t aIndex, nsAString& aResult);
void GetKeys(nsTArray<nsString>& aKeys);
void GetItem(DataSetType aDataSetType, const nsAString& aKey,
nsAString& aResult);
nsresult SetItem(const nsAString& aKey, const nsAString& aValue,
void GetKeys(DataSetType aDataSetType, nsTArray<nsString>& aKeys);
nsresult SetItem(DataSetType aDataSetType, const nsAString& aKey,
const nsAString& aValue, nsString& aOldValue);
nsresult RemoveItem(DataSetType aDataSetType, const nsAString& aKey,
nsString& aOldValue);
nsresult RemoveItem(const nsAString& aKey,
nsString& aOldValue);
void Clear();
void Clear(DataSetType aDataSetType, bool aByUserInteraction = true);
already_AddRefed<SessionStorageCache>
Clone() const;
@@ -46,10 +49,23 @@ public:
private:
~SessionStorageCache() = default;
struct DataSet
{
DataSet()
: mOriginQuotaUsage(0)
{}
bool ProcessUsageDelta(int64_t aDelta);
int64_t mOriginQuotaUsage;
nsDataHashtable<nsStringHashKey, nsString> mKeys;
};
DataSet* Set(DataSetType aDataSetType);
DataSet mDefaultSet;
DataSet mSessionSet;
bool mSessionDataSetActive;
};
} // dom namespace

19
dom/storage/SessionStorageManager.cpp
View File

@@ -212,7 +212,8 @@ SessionStorageManager::GetLocalStorageForPrincipal(nsIPrincipal* aPrincipal,
}
void
SessionStorageManager::ClearStorages(const OriginAttributesPattern& aPattern,
SessionStorageManager::ClearStorages(ClearStorageType aType,
const OriginAttributesPattern& aPattern,
const nsACString& aOriginScope)
{
for (auto iter1 = mOATable.Iter(); !iter1.Done(); iter1.Next()) {
@@ -228,7 +229,13 @@ SessionStorageManager::ClearStorages(const OriginAttributesPattern& aPattern,
for (auto iter2 = table->Iter(); !iter2.Done(); iter2.Next()) {
if (aOriginScope.IsEmpty() ||
StringBeginsWith(iter2.Key(), aOriginScope)) {
iter2.Data()->Clear();
if (aType == eAll) {
iter2.Data()->Clear(SessionStorageCache::eDefaultSetType, false);
iter2.Data()->Clear(SessionStorageCache::eSessionSetType, false);
} else {
MOZ_ASSERT(aType == eSessionOnly);
iter2.Data()->Clear(SessionStorageCache::eSessionSetType, false);
}
}
}
}
@@ -247,27 +254,27 @@ SessionStorageManager::Observe(const char* aTopic,
// Clear everything, caches + database
if (!strcmp(aTopic, "cookie-cleared")) {
ClearStorages(pattern, EmptyCString());
ClearStorages(eAll, pattern, EmptyCString());
return NS_OK;
}
// Clear from caches everything that has been stored
// while in session-only mode
if (!strcmp(aTopic, "session-only-cleared")) {
ClearStorages(pattern, aOriginScope);
ClearStorages(eSessionOnly, pattern, aOriginScope);
return NS_OK;
}
// Clear everything (including so and pb data) from caches and database
// for the gived domain and subdomains.
if (!strcmp(aTopic, "domain-data-cleared")) {
ClearStorages(pattern, aOriginScope);
ClearStorages(eAll, pattern, aOriginScope);
return NS_OK;
}
if (!strcmp(aTopic, "profile-change")) {
// For case caches are still referenced - clear them completely
ClearStorages(pattern, EmptyCString());
ClearStorages(eAll, pattern, EmptyCString());
mOATable.Clear();
return NS_OK;
}

8
dom/storage/SessionStorageManager.h
View File

@@ -35,8 +35,14 @@ private:
const nsAString& aOriginAttributesPattern,
const nsACString& aOriginScope) override;
enum ClearStorageType {
eAll,
eSessionOnly,
};
void
ClearStorages(const OriginAttributesPattern& aPattern,
ClearStorages(ClearStorageType aType,
const OriginAttributesPattern& aPattern,
const nsACString& aOriginScope);
typedef nsRefPtrHashtable<nsCStringHashKey, SessionStorageCache> OriginKeyHashTable;