dom/quota/PersistenceType.cpp

   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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "PersistenceType.h"
   8
   9 #include <utility>
  10 #include "nsIFile.h"
  11 #include "nsLiteralString.h"
  12 #include "nsString.h"
  13
  14 namespace mozilla::dom::quota {
  15
  16 namespace {
  17
  18 constexpr auto kPersistentCString = "persistent"_ns;
  19 constexpr auto kTemporaryCString = "temporary"_ns;
  20 constexpr auto kDefaultCString = "default"_ns;
  21 constexpr auto kPrivateCString = "private"_ns;
  22
  23 constexpr auto kPermanentString = u"permanent"_ns;
  24 constexpr auto kTemporaryString = u"temporary"_ns;
  25 constexpr auto kDefaultString = u"default"_ns;
  26 constexpr auto kPrivateString = u"private"_ns;
  27
  28 static_assert(PERSISTENCE_TYPE_PERSISTENT == 0 &&
  29                   PERSISTENCE_TYPE_TEMPORARY == 1 &&
  30                   PERSISTENCE_TYPE_DEFAULT == 2 &&
  31                   PERSISTENCE_TYPE_PRIVATE == 3 &&
  32                   PERSISTENCE_TYPE_INVALID == 4,
  33               "Incorrect enum values!");
  34
  35 template <PersistenceType type>
  36 struct PersistenceTypeTraits;
  37
  38 template <>
  39 struct PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT> {
  40   template <typename T>
  41   static T To();
  42
  43   static bool From(const nsACString& aString) {
  44     return aString == kPersistentCString;
  45   }
  46
  47   static bool From(const int32_t aInt32) { return aInt32 == 0; }
  48
  49   static bool From(nsIFile& aFile) {
  50     nsAutoString leafName;
  51     MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
  52     return leafName == kPermanentString;
  53   }
  54 };
  55
  56 template <>
  57 nsLiteralCString
  58 PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::To<nsLiteralCString>() {
  59   return kPersistentCString;
  60 }
  61
  62 template <>
  63 struct PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY> {
  64   template <typename T>
  65   static T To();
  66
  67   static bool From(const nsACString& aString) {
  68     return aString == kTemporaryCString;
  69   }
  70
  71   static bool From(const int32_t aInt32) { return aInt32 == 1; }
  72
  73   static bool From(nsIFile& aFile) {
  74     nsAutoString leafName;
  75     MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
  76     return leafName == kTemporaryString;
  77   }
  78 };
  79
  80 template <>
  81 nsLiteralCString
  82 PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::To<nsLiteralCString>() {
  83   return kTemporaryCString;
  84 }
  85
  86 template <>
  87 struct PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT> {
  88   template <typename T>
  89   static T To();
  90
  91   static bool From(const nsACString& aString) {
  92     return aString == kDefaultCString;
  93   }
  94
  95   static bool From(const int32_t aInt32) { return aInt32 == 2; }
  96
  97   static bool From(nsIFile& aFile) {
  98     nsAutoString leafName;
  99     MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
 100     return leafName == kDefaultString;
 101   }
 102 };
 103
 104 template <>
 105 nsLiteralCString
 106 PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::To<nsLiteralCString>() {
 107   return kDefaultCString;
 108 }
 109
 110 template <>
 111 struct PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE> {
 112   template <typename T>
 113   static T To();
 114
 115   static bool From(const nsACString& aString) {
 116     return aString == kPrivateCString;
 117   }
 118
 119   static bool From(const int32_t aInt32) { return aInt32 == 3; }
 120
 121   static bool From(nsIFile& aFile) {
 122     nsAutoString leafName;
 123     MOZ_ALWAYS_SUCCEEDS(aFile.GetLeafName(leafName));
 124     return leafName == kPrivateString;
 125   }
 126 };
 127
 128 template <>
 129 nsLiteralCString
 130 PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::To<nsLiteralCString>() {
 131   return kPrivateCString;
 132 }
 133
 134 template <typename T>
 135 Maybe<T> TypeTo_impl(const PersistenceType aPersistenceType) {
 136   switch (aPersistenceType) {
 137     case PERSISTENCE_TYPE_PERSISTENT:
 138       return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::To<T>());
 139
 140     case PERSISTENCE_TYPE_TEMPORARY:
 141       return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::To<T>());
 142
 143     case PERSISTENCE_TYPE_DEFAULT:
 144       return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::To<T>());
 145
 146     case PERSISTENCE_TYPE_PRIVATE:
 147       return Some(PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::To<T>());
 148
 149     default:
 150       return Nothing();
 151   }
 152 }
 153
 154 template <typename T>
 155 Maybe<PersistenceType> TypeFrom_impl(T& aData) {
 156   if (PersistenceTypeTraits<PERSISTENCE_TYPE_PERSISTENT>::From(aData)) {
 157     return Some(PERSISTENCE_TYPE_PERSISTENT);
 158   }
 159
 160   if (PersistenceTypeTraits<PERSISTENCE_TYPE_TEMPORARY>::From(aData)) {
 161     return Some(PERSISTENCE_TYPE_TEMPORARY);
 162   }
 163
 164   if (PersistenceTypeTraits<PERSISTENCE_TYPE_DEFAULT>::From(aData)) {
 165     return Some(PERSISTENCE_TYPE_DEFAULT);
 166   }
 167
 168   if (PersistenceTypeTraits<PERSISTENCE_TYPE_PRIVATE>::From(aData)) {
 169     return Some(PERSISTENCE_TYPE_PRIVATE);
 170   }
 171
 172   return Nothing();
 173 }
 174
 175 void BadPersistenceType() { MOZ_CRASH("Bad persistence type value!"); }
 176
 177 }  // namespace
 178
 179 bool IsValidPersistenceType(const PersistenceType aPersistenceType) {
 180   switch (aPersistenceType) {
 181     case PERSISTENCE_TYPE_PERSISTENT:
 182     case PERSISTENCE_TYPE_TEMPORARY:
 183     case PERSISTENCE_TYPE_DEFAULT:
 184     case PERSISTENCE_TYPE_PRIVATE:
 185       return true;
 186
 187     default:
 188       return false;
 189   }
 190 }
 191
 192 bool IsBestEffortPersistenceType(const PersistenceType aPersistenceType) {
 193   switch (aPersistenceType) {
 194     case PERSISTENCE_TYPE_TEMPORARY:
 195     case PERSISTENCE_TYPE_DEFAULT:
 196     case PERSISTENCE_TYPE_PRIVATE:
 197       return true;
 198
 199     case PERSISTENCE_TYPE_PERSISTENT:
 200     case PERSISTENCE_TYPE_INVALID:
 201     default:
 202       return false;
 203   }
 204 }
 205
 206 nsLiteralCString PersistenceTypeToString(
 207     const PersistenceType aPersistenceType) {
 208   const auto maybeString = TypeTo_impl<nsLiteralCString>(aPersistenceType);
 209   if (maybeString.isNothing()) {
 210     BadPersistenceType();
 211   }
 212   return maybeString.value();
 213 }
 214
 215 Maybe<PersistenceType> PersistenceTypeFromString(const nsACString& aString,
 216                                                  const fallible_t&) {
 217   return TypeFrom_impl(aString);
 218 }
 219
 220 PersistenceType PersistenceTypeFromString(const nsACString& aString) {
 221   const auto maybePersistenceType = TypeFrom_impl(aString);
 222   if (maybePersistenceType.isNothing()) {
 223     BadPersistenceType();
 224   }
 225   return maybePersistenceType.value();
 226 }
 227
 228 Maybe<PersistenceType> PersistenceTypeFromInt32(const int32_t aInt32,
 229                                                 const fallible_t&) {
 230   return TypeFrom_impl(aInt32);
 231 }
 232
 233 Maybe<PersistenceType> PersistenceTypeFromFile(nsIFile& aFile,
 234                                                const fallible_t&) {
 235   return TypeFrom_impl(aFile);
 236 }
 237
 238 std::array<PersistenceType, 2> ComplementaryPersistenceTypes(
 239     const PersistenceType aPersistenceType) {
 240   MOZ_ASSERT(aPersistenceType == PERSISTENCE_TYPE_DEFAULT ||
 241              aPersistenceType == PERSISTENCE_TYPE_TEMPORARY ||
 242              aPersistenceType == PERSISTENCE_TYPE_PRIVATE);
 243
 244   if (aPersistenceType == PERSISTENCE_TYPE_TEMPORARY) {
 245     return {PERSISTENCE_TYPE_DEFAULT, PERSISTENCE_TYPE_PRIVATE};
 246   }
 247
 248   if (aPersistenceType == PERSISTENCE_TYPE_DEFAULT) {
 249     return {PERSISTENCE_TYPE_TEMPORARY, PERSISTENCE_TYPE_PRIVATE};
 250   }
 251
 252   return {PERSISTENCE_TYPE_DEFAULT, PERSISTENCE_TYPE_TEMPORARY};
 253 }
 254
 255 }  // namespace mozilla::dom::quota