dom/quota/OriginScope.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_quota_originorpatternstring_h__
   8 #define mozilla_dom_quota_originorpatternstring_h__
   9
  10 #include "mozilla/dom/quota/QuotaCommon.h"
  11
  12 #include "mozilla/BasePrincipal.h"
  13 #include "mozilla/Variant.h"
  14
  15 BEGIN_QUOTA_NAMESPACE
  16
  17 class OriginScope {
  18   class Origin {
  19     nsCString mOrigin;
  20     nsCString mOriginNoSuffix;
  21     UniquePtr<OriginAttributes> mAttributes;
  22
  23    public:
  24     explicit Origin(const nsACString& aOrigin) : mOrigin(aOrigin) {
  25       InitMembers();
  26     }
  27
  28     Origin(const Origin& aOther)
  29         : mOrigin(aOther.mOrigin),
  30           mOriginNoSuffix(aOther.mOriginNoSuffix),
  31           mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes)) {}
  32
  33     Origin(Origin&& aOther) = default;
  34
  35     const nsACString& GetOrigin() const { return mOrigin; }
  36
  37     void SetOrigin(const nsACString& aOrigin) {
  38       mOrigin = aOrigin;
  39
  40       InitMembers();
  41     }
  42
  43     const nsACString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
  44
  45     const OriginAttributes& GetAttributes() const {
  46       MOZ_ASSERT(mAttributes);
  47
  48       return *mAttributes;
  49     }
  50
  51    private:
  52     void InitMembers() {
  53       mAttributes = MakeUnique<OriginAttributes>();
  54
  55       MOZ_ALWAYS_TRUE(
  56           mAttributes->PopulateFromOrigin(mOrigin, mOriginNoSuffix));
  57     }
  58   };
  59
  60   class Prefix {
  61     nsCString mOriginNoSuffix;
  62
  63    public:
  64     explicit Prefix(const nsACString& aOriginNoSuffix)
  65         : mOriginNoSuffix(aOriginNoSuffix) {}
  66
  67     const nsCString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
  68
  69     void SetOriginNoSuffix(const nsACString& aOriginNoSuffix) {
  70       mOriginNoSuffix = aOriginNoSuffix;
  71     }
  72   };
  73
  74   class Pattern {
  75     UniquePtr<OriginAttributesPattern> mPattern;
  76
  77    public:
  78     explicit Pattern(const OriginAttributesPattern& aPattern)
  79         : mPattern(MakeUnique<OriginAttributesPattern>(aPattern)) {}
  80
  81     explicit Pattern(const nsAString& aJSONPattern)
  82         : mPattern(MakeUnique<OriginAttributesPattern>()) {
  83       MOZ_ALWAYS_TRUE(mPattern->Init(aJSONPattern));
  84     }
  85
  86     Pattern(const Pattern& aOther)
  87         : mPattern(MakeUnique<OriginAttributesPattern>(*aOther.mPattern)) {}
  88
  89     Pattern(Pattern&& aOther) = default;
  90
  91     const OriginAttributesPattern& GetPattern() const {
  92       MOZ_ASSERT(mPattern);
  93
  94       return *mPattern;
  95     }
  96
  97     void SetPattern(const OriginAttributesPattern& aPattern) {
  98       mPattern = MakeUnique<OriginAttributesPattern>(aPattern);
  99     }
 100
 101     nsString GetJSONPattern() const {
 102       MOZ_ASSERT(mPattern);
 103
 104       nsString result;
 105       MOZ_ALWAYS_TRUE(mPattern->ToJSON(result));
 106
 107       return result;
 108     }
 109   };
 110
 111   struct Null {};
 112
 113   using DataType = Variant<Origin, Prefix, Pattern, Null>;
 114
 115   DataType mData;
 116
 117  public:
 118   OriginScope() : mData(Null()) {}
 119
 120   static OriginScope FromOrigin(const nsACString& aOrigin) {
 121     return OriginScope(std::move(Origin(aOrigin)));
 122   }
 123
 124   static OriginScope FromPrefix(const nsACString& aPrefix) {
 125     return OriginScope(std::move(Prefix(aPrefix)));
 126   }
 127
 128   static OriginScope FromPattern(const OriginAttributesPattern& aPattern) {
 129     return OriginScope(std::move(Pattern(aPattern)));
 130   }
 131
 132   static OriginScope FromJSONPattern(const nsAString& aJSONPattern) {
 133     return OriginScope(std::move(Pattern(aJSONPattern)));
 134   }
 135
 136   static OriginScope FromNull() { return OriginScope(std::move(Null())); }
 137
 138   bool IsOrigin() const { return mData.is<Origin>(); }
 139
 140   bool IsPrefix() const { return mData.is<Prefix>(); }
 141
 142   bool IsPattern() const { return mData.is<Pattern>(); }
 143
 144   bool IsNull() const { return mData.is<Null>(); }
 145
 146   void SetFromOrigin(const nsACString& aOrigin) {
 147     mData = AsVariant(Origin(aOrigin));
 148   }
 149
 150   void SetFromPrefix(const nsACString& aPrefix) {
 151     mData = AsVariant(Prefix(aPrefix));
 152   }
 153
 154   void SetFromPattern(const OriginAttributesPattern& aPattern) {
 155     mData = AsVariant(Pattern(aPattern));
 156   }
 157
 158   void SetFromJSONPattern(const nsAString& aJSONPattern) {
 159     mData = AsVariant(Pattern(aJSONPattern));
 160   }
 161
 162   void SetFromNull() { mData = AsVariant(Null()); }
 163
 164   const nsACString& GetOrigin() const {
 165     MOZ_ASSERT(IsOrigin());
 166
 167     return mData.as<Origin>().GetOrigin();
 168   }
 169
 170   void SetOrigin(const nsACString& aOrigin) {
 171     MOZ_ASSERT(IsOrigin());
 172
 173     mData.as<Origin>().SetOrigin(aOrigin);
 174   }
 175
 176   const nsACString& GetOriginNoSuffix() const {
 177     MOZ_ASSERT(IsOrigin() || IsPrefix());
 178
 179     if (IsOrigin()) {
 180       return mData.as<Origin>().GetOriginNoSuffix();
 181     }
 182     return mData.as<Prefix>().GetOriginNoSuffix();
 183   }
 184
 185   void SetOriginNoSuffix(const nsACString& aOriginNoSuffix) {
 186     MOZ_ASSERT(IsPrefix());
 187
 188     mData.as<Prefix>().SetOriginNoSuffix(aOriginNoSuffix);
 189   }
 190
 191   const OriginAttributesPattern& GetPattern() const {
 192     MOZ_ASSERT(IsPattern());
 193
 194     return mData.as<Pattern>().GetPattern();
 195   }
 196
 197   nsString GetJSONPattern() const {
 198     MOZ_ASSERT(IsPattern());
 199
 200     return mData.as<Pattern>().GetJSONPattern();
 201   }
 202
 203   void SetPattern(const OriginAttributesPattern& aPattern) {
 204     MOZ_ASSERT(IsPattern());
 205
 206     mData.as<Pattern>().SetPattern(aPattern);
 207   }
 208
 209   bool Matches(const OriginScope& aOther) const {
 210     struct Matcher {
 211       const OriginScope& mThis;
 212
 213       explicit Matcher(const OriginScope& aThis) : mThis(aThis) {}
 214
 215       bool match(const Origin& aOther) { return mThis.MatchesOrigin(aOther); }
 216
 217       bool match(const Prefix& aOther) { return mThis.MatchesPrefix(aOther); }
 218
 219       bool match(const Pattern& aOther) { return mThis.MatchesPattern(aOther); }
 220
 221       bool match(const Null& aOther) { return true; }
 222     };
 223
 224     return aOther.mData.match(Matcher(*this));
 225   }
 226
 227   OriginScope Clone() { return OriginScope(mData); }
 228
 229  private:
 230   // Move constructors
 231   explicit OriginScope(const Origin&& aOrigin) : mData(aOrigin) {}
 232
 233   explicit OriginScope(const Prefix&& aPrefix) : mData(aPrefix) {}
 234
 235   explicit OriginScope(const Pattern&& aPattern) : mData(aPattern) {}
 236
 237   explicit OriginScope(const Null&& aNull) : mData(aNull) {}
 238
 239   // Copy constructor
 240   explicit OriginScope(const DataType& aOther) : mData(aOther) {}
 241
 242   bool MatchesOrigin(const Origin& aOther) const {
 243     struct OriginMatcher {
 244       const Origin& mOther;
 245
 246       explicit OriginMatcher(const Origin& aOther) : mOther(aOther) {}
 247
 248       bool match(const Origin& aThis) {
 249         return aThis.GetOrigin().Equals(mOther.GetOrigin());
 250       }
 251
 252       bool match(const Prefix& aThis) {
 253         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 254       }
 255
 256       bool match(const Pattern& aThis) {
 257         return aThis.GetPattern().Matches(mOther.GetAttributes());
 258       }
 259
 260       bool match(const Null& aThis) {
 261         // Null covers everything.
 262         return true;
 263       }
 264     };
 265
 266     return mData.match(OriginMatcher(aOther));
 267   }
 268
 269   bool MatchesPrefix(const Prefix& aOther) const {
 270     struct PrefixMatcher {
 271       const Prefix& mOther;
 272
 273       explicit PrefixMatcher(const Prefix& aOther) : mOther(aOther) {}
 274
 275       bool match(const Origin& aThis) {
 276         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 277       }
 278
 279       bool match(const Prefix& aThis) {
 280         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 281       }
 282
 283       bool match(const Pattern& aThis) {
 284         // The match will be always true here because any origin attributes
 285         // pattern overlaps any origin prefix (an origin prefix targets all
 286         // origin attributes).
 287         return true;
 288       }
 289
 290       bool match(const Null& aThis) {
 291         // Null covers everything.
 292         return true;
 293       }
 294     };
 295
 296     return mData.match(PrefixMatcher(aOther));
 297   }
 298
 299   bool MatchesPattern(const Pattern& aOther) const {
 300     struct PatternMatcher {
 301       const Pattern& mOther;
 302
 303       explicit PatternMatcher(const Pattern& aOther) : mOther(aOther) {}
 304
 305       bool match(const Origin& aThis) {
 306         return mOther.GetPattern().Matches(aThis.GetAttributes());
 307       }
 308
 309       bool match(const Prefix& aThis) {
 310         // The match will be always true here because any origin attributes
 311         // pattern overlaps any origin prefix (an origin prefix targets all
 312         // origin attributes).
 313         return true;
 314       }
 315
 316       bool match(const Pattern& aThis) {
 317         return aThis.GetPattern().Overlaps(mOther.GetPattern());
 318       }
 319
 320       bool match(const Null& aThis) {
 321         // Null covers everything.
 322         return true;
 323       }
 324     };
 325
 326     PatternMatcher patternMatcher(aOther);
 327     return mData.match(PatternMatcher(aOther));
 328   }
 329
 330   bool operator==(const OriginScope& aOther) = delete;
 331 };
 332
 333 END_QUOTA_NAMESPACE
 334
 335 #endif  // mozilla_dom_quota_originorpatternstring_h__