tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

PersistenceType.cpp (7131B)

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