storage/mozStorageService.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
   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 #ifndef MOZSTORAGESERVICE_H
   8 #define MOZSTORAGESERVICE_H
   9
  10 #include "nsCOMPtr.h"
  11 #include "nsIFile.h"
  12 #include "nsIMemoryReporter.h"
  13 #include "nsIObserver.h"
  14 #include "nsTArray.h"
  15 #include "mozilla/Mutex.h"
  16 #include "mozilla/UniquePtr.h"
  17 #include "mozilla/intl/Collator.h"
  18
  19 #include "mozIStorageService.h"
  20
  21 class nsIMemoryReporter;
  22 struct sqlite3_vfs;
  23 namespace mozilla::intl {
  24 class Collator;
  25 }
  26
  27 namespace mozilla::storage {
  28
  29 class Connection;
  30 class Service : public mozIStorageService,
  31                 public nsIObserver,
  32                 public nsIMemoryReporter {
  33  public:
  34   /**
  35    * Initializes the service.  This must be called before any other function!
  36    */
  37   nsresult initialize();
  38
  39   /**
  40    * Compares two strings using the Service's locale-aware collation.
  41    *
  42    * @param  aStr1
  43    *         The string to be compared against aStr2.
  44    * @param  aStr2
  45    *         The string to be compared against aStr1.
  46    * @param  aSensitivity
  47    *         The sorting sensitivity.
  48    * @return aStr1 - aStr2.  That is, if aStr1 < aStr2, returns a negative
  49    *         number.  If aStr1 > aStr2, returns a positive number.  If
  50    *         aStr1 == aStr2, returns 0.
  51    */
  52   int localeCompareStrings(const nsAString& aStr1, const nsAString& aStr2,
  53                            mozilla::intl::Collator::Sensitivity aSensitivity);
  54
  55   static already_AddRefed<Service> getSingleton();
  56
  57   NS_DECL_THREADSAFE_ISUPPORTS
  58   NS_DECL_MOZISTORAGESERVICE
  59   NS_DECL_NSIOBSERVER
  60   NS_DECL_NSIMEMORYREPORTER
  61
  62   /**
  63    * Returns a boolean value indicating whether or not the given page size is
  64    * valid (currently understood as a power of 2 between 512 and 65536).
  65    */
  66   static bool pageSizeIsValid(int32_t aPageSize) {
  67     return aPageSize == 512 || aPageSize == 1024 || aPageSize == 2048 ||
  68            aPageSize == 4096 || aPageSize == 8192 || aPageSize == 16384 ||
  69            aPageSize == 32768 || aPageSize == 65536;
  70   }
  71
  72   static const int32_t kDefaultPageSize = 32768;
  73
  74   /**
  75    * Registers the connection with the storage service.  Connections are
  76    * registered so they can be iterated over.
  77    *
  78    * @pre mRegistrationMutex is not held
  79    *
  80    * @param  aConnection
  81    *         The connection to register.
  82    */
  83   void registerConnection(Connection* aConnection);
  84
  85   /**
  86    * Unregisters the connection with the storage service.
  87    *
  88    * @pre mRegistrationMutex is not held
  89    *
  90    * @param  aConnection
  91    *         The connection to unregister.
  92    */
  93   void unregisterConnection(Connection* aConnection);
  94
  95   /**
  96    * Gets the list of open connections.  Note that you must test each
  97    * connection with mozIStorageConnection::connectionReady before doing
  98    * anything with it, and skip it if it's not ready.
  99    *
 100    * @pre mRegistrationMutex is not held
 101    *
 102    * @param  aConnections
 103    *         An inout param;  it is cleared and the connections are appended to
 104    *         it.
 105    * @return The open connections.
 106    */
 107   void getConnections(nsTArray<RefPtr<Connection> >& aConnections);
 108
 109  private:
 110   Service();
 111   virtual ~Service();
 112
 113   /**
 114    * Used for 1) locking around calls when initializing connections so that we
 115    * can ensure that the state of sqlite3_enable_shared_cache is sane and 2)
 116    * synchronizing access to mLocaleCollation.
 117    */
 118   Mutex mMutex MOZ_UNANNOTATED;
 119
 120   struct AutoVFSRegistration {
 121     int Init(UniquePtr<sqlite3_vfs> aVFS);
 122     ~AutoVFSRegistration();
 123
 124    private:
 125     UniquePtr<sqlite3_vfs> mVFS;
 126   };
 127
 128   // The order of these members should match the order of Init calls in
 129   // initialize(), to ensure that the unregistration takes place in the reverse
 130   // order.
 131   AutoVFSRegistration mBaseSqliteVFS;
 132   AutoVFSRegistration mBaseExclSqliteVFS;
 133   AutoVFSRegistration mQuotaSqliteVFS;
 134   AutoVFSRegistration mObfuscatingSqliteVFS;
 135   AutoVFSRegistration mReadOnlyNoLockSqliteVFS;
 136
 137   /**
 138    * Protects mConnections.
 139    */
 140   Mutex mRegistrationMutex MOZ_UNANNOTATED;
 141
 142   /**
 143    * The list of connections we have created.  Modifications to it are
 144    * protected by |mRegistrationMutex|.
 145    */
 146   nsTArray<RefPtr<Connection> > mConnections;
 147
 148   /**
 149    * Frees as much heap memory as possible from all of the known open
 150    * connections.
 151    */
 152   void minimizeMemory();
 153
 154   /**
 155    * Lazily creates and returns a collator created from the application's
 156    * locale that all statements of all Connections of this Service may use.
 157    * Since the collator's lifetime is that of the Service and no statement may
 158    * execute outside the lifetime of the Service, this method returns a raw
 159    * pointer.
 160    */
 161   mozilla::intl::Collator* getCollator();
 162
 163   /**
 164    * Lazily created collator that all statements of all Connections of this
 165    * Service may use.  The collator is created from the application's locale.
 166    *
 167    * @note The collator is not thread-safe since the options can be changed
 168    * between calls. Access should be synchronized.
 169    */
 170   mozilla::UniquePtr<mozilla::intl::Collator> mCollator = nullptr;
 171
 172   nsCOMPtr<nsIFile> mProfileStorageFile;
 173
 174   nsCOMPtr<nsIMemoryReporter> mStorageSQLiteReporter;
 175
 176   static Service* gService;
 177
 178   mozilla::intl::Collator::Sensitivity mLastSensitivity;
 179 };
 180
 181 }  // namespace mozilla::storage
 182
 183 #endif /* MOZSTORAGESERVICE_H */