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 <utility>
  11 #include "mozilla/Assertions.h"
  12 #include "mozilla/OriginAttributes.h"
  13 #include "mozilla/UniquePtr.h"
  14 #include "mozilla/Variant.h"
  15 #include "mozilla/dom/quota/CommonMetadata.h"
  16 #include "nsStringFlags.h"
  17 #include "nsStringFwd.h"
  18
  19 namespace mozilla::dom::quota {
  20
  21 class OriginScope {
  22   class Origin {
  23     const PrincipalMetadata mPrincipalMetadata;
  24     nsCString mOriginNoSuffix;
  25     UniquePtr<OriginAttributes> mAttributes;
  26
  27    public:
  28     explicit Origin(const PrincipalMetadata& aPrincipalMetadata)
  29         : mPrincipalMetadata(aPrincipalMetadata) {
  30       InitMembers();
  31     }
  32
  33     Origin(const Origin& aOther)
  34         : mPrincipalMetadata(aOther.mPrincipalMetadata),
  35           mOriginNoSuffix(aOther.mOriginNoSuffix),
  36           mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes)) {}
  37
  38     Origin(Origin&& aOther) = default;
  39
  40     const PrincipalMetadata& GetPrincipalMetadata() const {
  41       return mPrincipalMetadata;
  42     }
  43
  44     const nsACString& GetGroup() const { return mPrincipalMetadata.mGroup; }
  45
  46     const nsACString& GetOrigin() const { return mPrincipalMetadata.mOrigin; }
  47
  48     const nsACString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
  49
  50     const OriginAttributes& GetAttributes() const {
  51       MOZ_ASSERT(mAttributes);
  52
  53       return *mAttributes;
  54     }
  55
  56    private:
  57     void InitMembers() {
  58       mAttributes = MakeUnique<OriginAttributes>();
  59
  60       MOZ_ALWAYS_TRUE(mAttributes->PopulateFromOrigin(
  61           mPrincipalMetadata.mOrigin, mOriginNoSuffix));
  62     }
  63   };
  64
  65   class Prefix {
  66     const PrincipalMetadata mPrincipalMetadata;
  67     nsCString mGroupNoSuffix;
  68     nsCString mOriginNoSuffix;
  69
  70    public:
  71     explicit Prefix(const PrincipalMetadata& aPrincipalMetadata)
  72         : mGroupNoSuffix(aPrincipalMetadata.mGroup),
  73           mOriginNoSuffix(aPrincipalMetadata.mOrigin) {}
  74
  75     const nsACString& GetGroupNoSuffix() const { return mGroupNoSuffix; }
  76
  77     const nsCString& GetOriginNoSuffix() const { return mOriginNoSuffix; }
  78   };
  79
  80   class Group {
  81     nsCString mGroup;
  82     nsCString mGroupNoSuffix;
  83     UniquePtr<OriginAttributes> mAttributes;
  84
  85    public:
  86     explicit Group(const nsACString& aGroup) : mGroup(aGroup) { InitMembers(); }
  87
  88     Group(const Group& aOther)
  89         : mGroup(aOther.mGroup),
  90           mGroupNoSuffix(aOther.mGroupNoSuffix),
  91           mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes)) {}
  92
  93     Group(Group&& aOther) = default;
  94
  95     const nsACString& GetGroup() const { return mGroup; }
  96
  97     const nsACString& GetGroupNoSuffix() const { return mGroupNoSuffix; }
  98
  99     const OriginAttributes& GetAttributes() const {
 100       MOZ_ASSERT(mAttributes);
 101
 102       return *mAttributes;
 103     }
 104
 105    private:
 106     void InitMembers() {
 107       mAttributes = MakeUnique<OriginAttributes>();
 108
 109       MOZ_ALWAYS_TRUE(mAttributes->PopulateFromOrigin(mGroup, mGroupNoSuffix));
 110     }
 111   };
 112
 113   class Pattern {
 114     UniquePtr<OriginAttributesPattern> mPattern;
 115
 116    public:
 117     explicit Pattern(const OriginAttributesPattern& aPattern)
 118         : mPattern(MakeUnique<OriginAttributesPattern>(aPattern)) {}
 119
 120     explicit Pattern(const nsAString& aJSONPattern)
 121         : mPattern(MakeUnique<OriginAttributesPattern>()) {
 122       MOZ_ALWAYS_TRUE(mPattern->Init(aJSONPattern));
 123     }
 124
 125     Pattern(const Pattern& aOther)
 126         : mPattern(MakeUnique<OriginAttributesPattern>(*aOther.mPattern)) {}
 127
 128     Pattern(Pattern&& aOther) = default;
 129
 130     const OriginAttributesPattern& GetPattern() const {
 131       MOZ_ASSERT(mPattern);
 132
 133       return *mPattern;
 134     }
 135
 136     nsString GetJSONPattern() const {
 137       MOZ_ASSERT(mPattern);
 138
 139       nsString result;
 140       MOZ_ALWAYS_TRUE(mPattern->ToJSON(result));
 141
 142       return result;
 143     }
 144   };
 145
 146   struct Null {};
 147
 148   using DataType = Variant<Origin, Prefix, Group, Pattern, Null>;
 149
 150   DataType mData;
 151
 152  public:
 153   OriginScope() : mData(Null()) {}
 154
 155   // XXX Consider renaming these static methods to Create
 156   static OriginScope FromOrigin(const PrincipalMetadata& aPrincipalMetadata) {
 157     return OriginScope(std::move(Origin(aPrincipalMetadata)));
 158   }
 159
 160   static OriginScope FromPrefix(const PrincipalMetadata& aPrincipalMetadata) {
 161     return OriginScope(std::move(Prefix(aPrincipalMetadata)));
 162   }
 163
 164   static OriginScope FromGroup(const nsACString& aGroup) {
 165     return OriginScope(std::move(Group(aGroup)));
 166   }
 167
 168   static OriginScope FromPattern(const OriginAttributesPattern& aPattern) {
 169     return OriginScope(std::move(Pattern(aPattern)));
 170   }
 171
 172   static OriginScope FromJSONPattern(const nsAString& aJSONPattern) {
 173     return OriginScope(std::move(Pattern(aJSONPattern)));
 174   }
 175
 176   static OriginScope FromNull() { return OriginScope(std::move(Null())); }
 177
 178   bool IsOrigin() const { return mData.is<Origin>(); }
 179
 180   bool IsPrefix() const { return mData.is<Prefix>(); }
 181
 182   bool IsPattern() const { return mData.is<Pattern>(); }
 183
 184   bool IsNull() const { return mData.is<Null>(); }
 185
 186   void SetFromOrigin(const PrincipalMetadata& aPrincipalMetadata) {
 187     mData = AsVariant(Origin(aPrincipalMetadata));
 188   }
 189
 190   void SetFromPrefix(const PrincipalMetadata& aPrincipalMetadata) {
 191     mData = AsVariant(Prefix(aPrincipalMetadata));
 192   }
 193
 194   void SetFromPattern(const OriginAttributesPattern& aPattern) {
 195     mData = AsVariant(Pattern(aPattern));
 196   }
 197
 198   void SetFromJSONPattern(const nsAString& aJSONPattern) {
 199     mData = AsVariant(Pattern(aJSONPattern));
 200   }
 201
 202   void SetFromNull() { mData = AsVariant(Null()); }
 203
 204   const PrincipalMetadata& GetPrincipalMetadata() const {
 205     MOZ_ASSERT(IsOrigin());
 206
 207     return mData.as<Origin>().GetPrincipalMetadata();
 208   }
 209
 210   const nsACString& GetOrigin() const {
 211     MOZ_ASSERT(IsOrigin());
 212
 213     return mData.as<Origin>().GetOrigin();
 214   }
 215
 216   const nsACString& GetOriginNoSuffix() const {
 217     MOZ_ASSERT(IsOrigin() || IsPrefix());
 218
 219     if (IsOrigin()) {
 220       return mData.as<Origin>().GetOriginNoSuffix();
 221     }
 222     return mData.as<Prefix>().GetOriginNoSuffix();
 223   }
 224
 225   const OriginAttributesPattern& GetPattern() const {
 226     MOZ_ASSERT(IsPattern());
 227
 228     return mData.as<Pattern>().GetPattern();
 229   }
 230
 231   nsString GetJSONPattern() const {
 232     MOZ_ASSERT(IsPattern());
 233
 234     return mData.as<Pattern>().GetJSONPattern();
 235   }
 236
 237   bool Matches(const OriginScope& aOther) const {
 238     struct Matcher {
 239       const OriginScope& mThis;
 240
 241       explicit Matcher(const OriginScope& aThis) : mThis(aThis) {}
 242
 243       bool operator()(const Origin& aOther) {
 244         return mThis.MatchesOrigin(aOther);
 245       }
 246
 247       bool operator()(const Prefix& aOther) {
 248         return mThis.MatchesPrefix(aOther);
 249       }
 250
 251       bool operator()(const Group& aOther) {
 252         return mThis.MatchesGroup(aOther);
 253       }
 254
 255       bool operator()(const Pattern& aOther) {
 256         return mThis.MatchesPattern(aOther);
 257       }
 258
 259       bool operator()(const Null& aOther) { return true; }
 260     };
 261
 262     return aOther.mData.match(Matcher(*this));
 263   }
 264
 265   OriginScope Clone() { return OriginScope(mData); }
 266
 267  private:
 268   // Move constructors
 269   explicit OriginScope(const Origin&& aOrigin) : mData(aOrigin) {}
 270
 271   explicit OriginScope(const Prefix&& aPrefix) : mData(aPrefix) {}
 272
 273   explicit OriginScope(const Group&& aGroup) : mData(aGroup) {}
 274
 275   explicit OriginScope(const Pattern&& aPattern) : mData(aPattern) {}
 276
 277   explicit OriginScope(const Null&& aNull) : mData(aNull) {}
 278
 279   // Copy constructor
 280   explicit OriginScope(const DataType& aOther) : mData(aOther) {}
 281
 282   bool MatchesOrigin(const Origin& aOther) const {
 283     struct OriginMatcher {
 284       const Origin& mOther;
 285
 286       explicit OriginMatcher(const Origin& aOther) : mOther(aOther) {}
 287
 288       bool operator()(const Origin& aThis) {
 289         return aThis.GetOrigin().Equals(mOther.GetOrigin());
 290       }
 291
 292       bool operator()(const Prefix& aThis) {
 293         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 294       }
 295
 296       bool operator()(const Group& aThis) {
 297         return aThis.GetGroup().Equals(mOther.GetGroup());
 298       }
 299
 300       bool operator()(const Pattern& aThis) {
 301         return aThis.GetPattern().Matches(mOther.GetAttributes());
 302       }
 303
 304       bool operator()(const Null& aThis) {
 305         // Null covers everything.
 306         return true;
 307       }
 308     };
 309
 310     return mData.match(OriginMatcher(aOther));
 311   }
 312
 313   bool MatchesPrefix(const Prefix& aOther) const {
 314     struct PrefixMatcher {
 315       const Prefix& mOther;
 316
 317       explicit PrefixMatcher(const Prefix& aOther) : mOther(aOther) {}
 318
 319       bool operator()(const Origin& aThis) {
 320         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 321       }
 322
 323       bool operator()(const Prefix& aThis) {
 324         return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
 325       }
 326
 327       bool operator()(const Group& aThis) {
 328         return aThis.GetGroupNoSuffix().Equals(mOther.GetGroupNoSuffix());
 329       }
 330
 331       bool operator()(const Pattern& aThis) {
 332         // The match will be always true here because any origin attributes
 333         // pattern overlaps any origin prefix (an origin prefix targets all
 334         // origin attributes).
 335         return true;
 336       }
 337
 338       bool operator()(const Null& aThis) {
 339         // Null covers everything.
 340         return true;
 341       }
 342     };
 343
 344     return mData.match(PrefixMatcher(aOther));
 345   }
 346
 347   bool MatchesGroup(const Group& aOther) const {
 348     struct GroupMatcher {
 349       const Group& mOther;
 350
 351       explicit GroupMatcher(const Group& aOther) : mOther(aOther) {}
 352
 353       bool operator()(const Origin& aThis) {
 354         return aThis.GetGroup().Equals(mOther.GetGroup());
 355       }
 356
 357       bool operator()(const Prefix& aThis) {
 358         return aThis.GetGroupNoSuffix().Equals(mOther.GetGroupNoSuffix());
 359       }
 360
 361       bool operator()(const Group& aThis) {
 362         return aThis.GetGroup().Equals(mOther.GetGroup());
 363       }
 364
 365       bool operator()(const Pattern& aThis) {
 366         return aThis.GetPattern().Matches(mOther.GetAttributes());
 367       }
 368
 369       bool operator()(const Null& aThis) {
 370         // Null covers everything.
 371         return true;
 372       }
 373     };
 374
 375     return mData.match(GroupMatcher(aOther));
 376   }
 377
 378   bool MatchesPattern(const Pattern& aOther) const {
 379     struct PatternMatcher {
 380       const Pattern& mOther;
 381
 382       explicit PatternMatcher(const Pattern& aOther) : mOther(aOther) {}
 383
 384       bool operator()(const Origin& aThis) {
 385         return mOther.GetPattern().Matches(aThis.GetAttributes());
 386       }
 387
 388       bool operator()(const Prefix& aThis) {
 389         // The match will be always true here because any origin attributes
 390         // pattern overlaps any origin prefix (an origin prefix targets all
 391         // origin attributes).
 392         return true;
 393       }
 394
 395       bool operator()(const Group& aThis) {
 396         return mOther.GetPattern().Matches(aThis.GetAttributes());
 397       }
 398
 399       bool operator()(const Pattern& aThis) {
 400         return aThis.GetPattern().Overlaps(mOther.GetPattern());
 401       }
 402
 403       bool operator()(const Null& aThis) {
 404         // Null covers everything.
 405         return true;
 406       }
 407     };
 408
 409     PatternMatcher patternMatcher(aOther);
 410     return mData.match(PatternMatcher(aOther));
 411   }
 412
 413   bool operator==(const OriginScope& aOther) = delete;
 414 };
 415
 416 }  // namespace mozilla::dom::quota
 417
 418 #endif  // mozilla_dom_quota_originorpatternstring_h__