Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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,
#ifndef mozilla_dom_quota_originorpatternstring_h__
#define mozilla_dom_quota_originorpatternstring_h__
#include <utility>
#include "mozilla/Assertions.h"
#include "mozilla/OriginAttributes.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Variant.h"
#include "mozilla/dom/quota/CommonMetadata.h"
#include "nsStringFlags.h"
#include "nsStringFwd.h"
namespace mozilla::dom::quota {
class OriginScope {
class Origin {
const PrincipalMetadata mPrincipalMetadata;
nsCString mOriginNoSuffix;
UniquePtr<OriginAttributes> mAttributes;
public:
explicit Origin(const PrincipalMetadata& aPrincipalMetadata)
: mPrincipalMetadata(aPrincipalMetadata) {
InitMembers();
}
Origin(const Origin& aOther)
: mPrincipalMetadata(aOther.mPrincipalMetadata),
mOriginNoSuffix(aOther.mOriginNoSuffix),
mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes)) {}
Origin(Origin&& aOther) = default;
const PrincipalMetadata& GetPrincipalMetadata() const {
return mPrincipalMetadata;
}
const nsACString& GetGroup() const { return mPrincipalMetadata.mGroup; }
const nsACString& GetOrigin() const { return mPrincipalMetadata.mOrigin; }
const nsACString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
const OriginAttributes& GetAttributes() const {
MOZ_ASSERT(mAttributes);
return *mAttributes;
}
private:
void InitMembers() {
mAttributes = MakeUnique<OriginAttributes>();
MOZ_ALWAYS_TRUE(mAttributes->PopulateFromOrigin(
mPrincipalMetadata.mOrigin, mOriginNoSuffix));
}
};
class Prefix {
const PrincipalMetadata mPrincipalMetadata;
nsCString mGroupNoSuffix;
nsCString mOriginNoSuffix;
public:
explicit Prefix(const PrincipalMetadata& aPrincipalMetadata)
: mGroupNoSuffix(aPrincipalMetadata.mGroup),
mOriginNoSuffix(aPrincipalMetadata.mOrigin) {}
const nsACString& GetGroupNoSuffix() const { return mGroupNoSuffix; }
const nsCString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
};
class Group {
nsCString mGroup;
nsCString mGroupNoSuffix;
UniquePtr<OriginAttributes> mAttributes;
public:
explicit Group(const nsACString& aGroup) : mGroup(aGroup) { InitMembers(); }
Group(const Group& aOther)
: mGroup(aOther.mGroup),
mGroupNoSuffix(aOther.mGroupNoSuffix),
mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes)) {}
Group(Group&& aOther) = default;
const nsACString& GetGroup() const { return mGroup; }
const nsACString& GetGroupNoSuffix() const { return mGroupNoSuffix; }
const OriginAttributes& GetAttributes() const {
MOZ_ASSERT(mAttributes);
return *mAttributes;
}
private:
void InitMembers() {
mAttributes = MakeUnique<OriginAttributes>();
MOZ_ALWAYS_TRUE(mAttributes->PopulateFromOrigin(mGroup, mGroupNoSuffix));
}
};
class Pattern {
UniquePtr<OriginAttributesPattern> mPattern;
public:
explicit Pattern(const OriginAttributesPattern& aPattern)
: mPattern(MakeUnique<OriginAttributesPattern>(aPattern)) {}
explicit Pattern(const nsAString& aJSONPattern)
: mPattern(MakeUnique<OriginAttributesPattern>()) {
MOZ_ALWAYS_TRUE(mPattern->Init(aJSONPattern));
}
Pattern(const Pattern& aOther)
: mPattern(MakeUnique<OriginAttributesPattern>(*aOther.mPattern)) {}
Pattern(Pattern&& aOther) = default;
const OriginAttributesPattern& GetPattern() const {
MOZ_ASSERT(mPattern);
return *mPattern;
}
nsString GetJSONPattern() const {
MOZ_ASSERT(mPattern);
nsString result;
MOZ_ALWAYS_TRUE(mPattern->ToJSON(result));
return result;
}
};
struct Null {};
using DataType = Variant<Origin, Prefix, Group, Pattern, Null>;
DataType mData;
public:
OriginScope() : mData(Null()) {}
// XXX Consider renaming these static methods to Create
static OriginScope FromOrigin(const PrincipalMetadata& aPrincipalMetadata) {
return OriginScope(std::move(Origin(aPrincipalMetadata)));
}
static OriginScope FromPrefix(const PrincipalMetadata& aPrincipalMetadata) {
return OriginScope(std::move(Prefix(aPrincipalMetadata)));
}
static OriginScope FromGroup(const nsACString& aGroup) {
return OriginScope(std::move(Group(aGroup)));
}
static OriginScope FromPattern(const OriginAttributesPattern& aPattern) {
return OriginScope(std::move(Pattern(aPattern)));
}
static OriginScope FromJSONPattern(const nsAString& aJSONPattern) {
return OriginScope(std::move(Pattern(aJSONPattern)));
}
static OriginScope FromNull() { return OriginScope(std::move(Null())); }
bool IsOrigin() const { return mData.is<Origin>(); }
bool IsPrefix() const { return mData.is<Prefix>(); }
bool IsPattern() const { return mData.is<Pattern>(); }
bool IsNull() const { return mData.is<Null>(); }
void SetFromOrigin(const PrincipalMetadata& aPrincipalMetadata) {
mData = AsVariant(Origin(aPrincipalMetadata));
}
void SetFromPrefix(const PrincipalMetadata& aPrincipalMetadata) {
mData = AsVariant(Prefix(aPrincipalMetadata));
}
void SetFromPattern(const OriginAttributesPattern& aPattern) {
mData = AsVariant(Pattern(aPattern));
}
void SetFromJSONPattern(const nsAString& aJSONPattern) {
mData = AsVariant(Pattern(aJSONPattern));
}
void SetFromNull() { mData = AsVariant(Null()); }
const PrincipalMetadata& GetPrincipalMetadata() const {
MOZ_ASSERT(IsOrigin());
return mData.as<Origin>().GetPrincipalMetadata();
}
const nsACString& GetOrigin() const {
MOZ_ASSERT(IsOrigin());
return mData.as<Origin>().GetOrigin();
}
const nsACString& GetOriginNoSuffix() const {
MOZ_ASSERT(IsOrigin() || IsPrefix());
if (IsOrigin()) {
return mData.as<Origin>().GetOriginNoSuffix();
}
return mData.as<Prefix>().GetOriginNoSuffix();
}
const OriginAttributesPattern& GetPattern() const {
MOZ_ASSERT(IsPattern());
return mData.as<Pattern>().GetPattern();
}
nsString GetJSONPattern() const {
MOZ_ASSERT(IsPattern());
return mData.as<Pattern>().GetJSONPattern();
}
bool Matches(const OriginScope& aOther) const {
struct Matcher {
const OriginScope& mThis;
explicit Matcher(const OriginScope& aThis) : mThis(aThis) {}
bool operator()(const Origin& aOther) {
return mThis.MatchesOrigin(aOther);
}
bool operator()(const Prefix& aOther) {
return mThis.MatchesPrefix(aOther);
}
bool operator()(const Group& aOther) {
return mThis.MatchesGroup(aOther);
}
bool operator()(const Pattern& aOther) {
return mThis.MatchesPattern(aOther);
}
bool operator()(const Null& aOther) { return true; }
};
return aOther.mData.match(Matcher(*this));
}
OriginScope Clone() { return OriginScope(mData); }
private:
// Move constructors
explicit OriginScope(const Origin&& aOrigin) : mData(aOrigin) {}
explicit OriginScope(const Prefix&& aPrefix) : mData(aPrefix) {}
explicit OriginScope(const Group&& aGroup) : mData(aGroup) {}
explicit OriginScope(const Pattern&& aPattern) : mData(aPattern) {}
explicit OriginScope(const Null&& aNull) : mData(aNull) {}
// Copy constructor
explicit OriginScope(const DataType& aOther) : mData(aOther) {}
bool MatchesOrigin(const Origin& aOther) const {
struct OriginMatcher {
const Origin& mOther;
explicit OriginMatcher(const Origin& aOther) : mOther(aOther) {}
bool operator()(const Origin& aThis) {
return aThis.GetOrigin().Equals(mOther.GetOrigin());
}
bool operator()(const Prefix& aThis) {
return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
}
bool operator()(const Group& aThis) {
return aThis.GetGroup().Equals(mOther.GetGroup());
}
bool operator()(const Pattern& aThis) {
return aThis.GetPattern().Matches(mOther.GetAttributes());
}
bool operator()(const Null& aThis) {
// Null covers everything.
return true;
}
};
return mData.match(OriginMatcher(aOther));
}
bool MatchesPrefix(const Prefix& aOther) const {
struct PrefixMatcher {
const Prefix& mOther;
explicit PrefixMatcher(const Prefix& aOther) : mOther(aOther) {}
bool operator()(const Origin& aThis) {
return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
}
bool operator()(const Prefix& aThis) {
return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
}
bool operator()(const Group& aThis) {
return aThis.GetGroupNoSuffix().Equals(mOther.GetGroupNoSuffix());
}
bool operator()(const Pattern& aThis) {
// The match will be always true here because any origin attributes
// pattern overlaps any origin prefix (an origin prefix targets all
// origin attributes).
return true;
}
bool operator()(const Null& aThis) {
// Null covers everything.
return true;
}
};
return mData.match(PrefixMatcher(aOther));
}
bool MatchesGroup(const Group& aOther) const {
struct GroupMatcher {
const Group& mOther;
explicit GroupMatcher(const Group& aOther) : mOther(aOther) {}
bool operator()(const Origin& aThis) {
return aThis.GetGroup().Equals(mOther.GetGroup());
}
bool operator()(const Prefix& aThis) {
return aThis.GetGroupNoSuffix().Equals(mOther.GetGroupNoSuffix());
}
bool operator()(const Group& aThis) {
return aThis.GetGroup().Equals(mOther.GetGroup());
}
bool operator()(const Pattern& aThis) {
return aThis.GetPattern().Matches(mOther.GetAttributes());
}
bool operator()(const Null& aThis) {
// Null covers everything.
return true;
}
};
return mData.match(GroupMatcher(aOther));
}
bool MatchesPattern(const Pattern& aOther) const {
struct PatternMatcher {
const Pattern& mOther;
explicit PatternMatcher(const Pattern& aOther) : mOther(aOther) {}
bool operator()(const Origin& aThis) {
return mOther.GetPattern().Matches(aThis.GetAttributes());
}
bool operator()(const Prefix& aThis) {
// The match will be always true here because any origin attributes
// pattern overlaps any origin prefix (an origin prefix targets all
// origin attributes).
return true;
}
bool operator()(const Group& aThis) {
return mOther.GetPattern().Matches(aThis.GetAttributes());
}
bool operator()(const Pattern& aThis) {
return aThis.GetPattern().Overlaps(mOther.GetPattern());
}
bool operator()(const Null& aThis) {
// Null covers everything.
return true;
}
};
PatternMatcher patternMatcher(aOther);
return mData.match(PatternMatcher(aOther));
}
bool operator==(const OriginScope& aOther) = delete;
};
} // namespace mozilla::dom::quota
#endif // mozilla_dom_quota_originorpatternstring_h__