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