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