gecko-dev/dom/quota/OriginScope.h

/* -*- 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/. */

#ifndef mozilla_dom_quota_originorpatternstring_h__
#define mozilla_dom_quota_originorpatternstring_h__

#include "mozilla/dom/quota/QuotaCommon.h"

#include "mozilla/BasePrincipal.h"
#include "mozilla/Variant.h"

BEGIN_QUOTA_NAMESPACE

class OriginScope
{
  class Origin
  {
    nsCString mOrigin;
    nsCString mOriginNoSuffix;
    UniquePtr<OriginAttributes> mAttributes;

  public:
    explicit Origin(const nsACString& aOrigin)
      : mOrigin(aOrigin)
    {
      InitMembers();
    }

    Origin(const Origin& aOther)
      : mOrigin(aOther.mOrigin)
      , mOriginNoSuffix(aOther.mOriginNoSuffix)
      , mAttributes(MakeUnique<OriginAttributes>(*aOther.mAttributes))
    { }

    Origin(Origin&& aOther) = default;

    const nsACString&
    GetOrigin() const
    {
      return mOrigin;
    }

    void
    SetOrigin(const nsACString& aOrigin)
    {
      mOrigin = aOrigin;

      InitMembers();
    }

    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(mOrigin,
                                                      mOriginNoSuffix));
    }
  };

  class Prefix
  {
    nsCString mOriginNoSuffix;

  public:
    explicit Prefix(const nsACString& aOriginNoSuffix)
      : mOriginNoSuffix(aOriginNoSuffix)
    { }

    const nsCString&
    GetOriginNoSuffix() const
    {
      return mOriginNoSuffix;
    }

    void
    SetOriginNoSuffix(const nsACString& aOriginNoSuffix)
    {
      mOriginNoSuffix = aOriginNoSuffix;
    }
  };

  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;
    }

    void
    SetPattern(const OriginAttributesPattern& aPattern)
    {
      mPattern = MakeUnique<OriginAttributesPattern>(aPattern);
    }

    nsString
    GetJSONPattern() const
    {
      MOZ_ASSERT(mPattern);

      nsString result;
      MOZ_ALWAYS_TRUE(mPattern->ToJSON(result));

      return result;
    }
  };

  struct Null
  { };

  using DataType = Variant<Origin, Prefix, Pattern, Null>;

  DataType mData;

public:
  OriginScope()
    : mData(Null())
  { }

  static OriginScope
  FromOrigin(const nsACString& aOrigin)
  {
    return OriginScope(std::move(Origin(aOrigin)));
  }

  static OriginScope
  FromPrefix(const nsACString& aPrefix)
  {
    return OriginScope(std::move(Prefix(aPrefix)));
  }

  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 nsACString& aOrigin)
  {
    mData = AsVariant(Origin(aOrigin));
  }

  void
  SetFromPrefix(const nsACString& aPrefix)
  {
    mData = AsVariant(Prefix(aPrefix));
  }

  void
  SetFromPattern(const OriginAttributesPattern& aPattern)
  {
    mData = AsVariant(Pattern(aPattern));
  }

  void
  SetFromJSONPattern(const nsAString& aJSONPattern)
  {
    mData = AsVariant(Pattern(aJSONPattern));
  }

  void
  SetFromNull()
  {
    mData = AsVariant(Null());
  }

  const nsACString&
  GetOrigin() const
  {
    MOZ_ASSERT(IsOrigin());

    return mData.as<Origin>().GetOrigin();
  }

  void
  SetOrigin(const nsACString& aOrigin)
  {
    MOZ_ASSERT(IsOrigin());

    mData.as<Origin>().SetOrigin(aOrigin);
  }

  const nsACString&
  GetOriginNoSuffix() const
  {
    MOZ_ASSERT(IsOrigin() || IsPrefix());

    if (IsOrigin()) {
      return mData.as<Origin>().GetOriginNoSuffix();
    }
    return mData.as<Prefix>().GetOriginNoSuffix();
  }

  void
  SetOriginNoSuffix(const nsACString& aOriginNoSuffix)
  {
    MOZ_ASSERT(IsPrefix());

    mData.as<Prefix>().SetOriginNoSuffix(aOriginNoSuffix);
  }

  const OriginAttributesPattern&
  GetPattern() const
  {
    MOZ_ASSERT(IsPattern());

    return mData.as<Pattern>().GetPattern();
  }

  nsString
  GetJSONPattern() const
  {
    MOZ_ASSERT(IsPattern());

    return mData.as<Pattern>().GetJSONPattern();
  }

  void
  SetPattern(const OriginAttributesPattern& aPattern)
  {
    MOZ_ASSERT(IsPattern());

    mData.as<Pattern>().SetPattern(aPattern);
  }

  bool
  Matches(const OriginScope& aOther) const
  {
    struct Matcher
    {
      const OriginScope& mThis;

      explicit Matcher(const OriginScope& aThis)
        : mThis(aThis)
      { }

      bool
      match(const Origin& aOther) {
        return mThis.MatchesOrigin(aOther);
      }

      bool
      match(const Prefix& aOther) {
        return mThis.MatchesPrefix(aOther);
      }

      bool
      match(const Pattern& aOther) {
        return mThis.MatchesPattern(aOther);
      }

      bool
      match(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 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
      match(const Origin& aThis) {
        return aThis.GetOrigin().Equals(mOther.GetOrigin());
      }

      bool
      match(const Prefix& aThis) {
        return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
      }

      bool
      match(const Pattern& aThis) {
        return aThis.GetPattern().Matches(mOther.GetAttributes());
      }

      bool
      match(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
      match(const Origin& aThis) {
        return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
      }

      bool
      match(const Prefix& aThis) {
        return aThis.GetOriginNoSuffix().Equals(mOther.GetOriginNoSuffix());
      }

      bool
      match(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
      match(const Null& aThis) {
        // Null covers everything.
        return true;
      }
    };

    return mData.match(PrefixMatcher(aOther));
  }

  bool
  MatchesPattern(const Pattern& aOther) const
  {
    struct PatternMatcher
    {
      const Pattern& mOther;

      explicit PatternMatcher(const Pattern& aOther)
        : mOther(aOther)
      { }

      bool
      match(const Origin& aThis) {
        return mOther.GetPattern().Matches(aThis.GetAttributes());
      }

      bool
      match(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
      match(const Pattern& aThis) {
        return aThis.GetPattern().Overlaps(mOther.GetPattern());
      }

      bool
      match(const Null& aThis) {
        // Null covers everything.
        return true;
      }
    };

    PatternMatcher patternMatcher(aOther);
    return mData.match(PatternMatcher(aOther));
  }

  bool
  operator==(const OriginScope& aOther) = delete;
};

END_QUOTA_NAMESPACE

#endif // mozilla_dom_quota_originorpatternstring_h__