summaryrefslogtreecommitdiffstats
path: root/storage/mozStorageService.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /storage/mozStorageService.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'storage/mozStorageService.cpp')
-rw-r--r--storage/mozStorageService.cpp982
1 files changed, 982 insertions, 0 deletions
diff --git a/storage/mozStorageService.cpp b/storage/mozStorageService.cpp
new file mode 100644
index 000000000..4f288ad42
--- /dev/null
+++ b/storage/mozStorageService.cpp
@@ -0,0 +1,982 @@
+/* -*- 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/. */
+
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+
+#include "mozStorageService.h"
+#include "mozStorageConnection.h"
+#include "nsAutoPtr.h"
+#include "nsCollationCID.h"
+#include "nsEmbedCID.h"
+#include "nsThreadUtils.h"
+#include "mozStoragePrivateHelpers.h"
+#include "nsILocale.h"
+#include "nsILocaleService.h"
+#include "nsIXPConnect.h"
+#include "nsIObserverService.h"
+#include "nsIPropertyBag2.h"
+#include "mozilla/Services.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/LateWriteChecks.h"
+#include "mozIStorageCompletionCallback.h"
+#include "mozIStoragePendingStatement.h"
+
+#include "sqlite3.h"
+
+#ifdef SQLITE_OS_WIN
+// "windows.h" was included and it can #define lots of things we care about...
+#undef CompareString
+#endif
+
+#include "nsIPromptService.h"
+
+#ifdef MOZ_STORAGE_MEMORY
+# include "mozmemory.h"
+# ifdef MOZ_DMD
+# include "DMD.h"
+# endif
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+//// Defines
+
+#define PREF_TS_SYNCHRONOUS "toolkit.storage.synchronous"
+#define PREF_TS_SYNCHRONOUS_DEFAULT 1
+
+#define PREF_TS_PAGESIZE "toolkit.storage.pageSize"
+
+// This value must be kept in sync with the value of SQLITE_DEFAULT_PAGE_SIZE in
+// db/sqlite3/src/Makefile.in.
+#define PREF_TS_PAGESIZE_DEFAULT 32768
+
+namespace mozilla {
+namespace storage {
+
+////////////////////////////////////////////////////////////////////////////////
+//// Memory Reporting
+
+#ifdef MOZ_DMD
+static mozilla::Atomic<size_t> gSqliteMemoryUsed;
+#endif
+
+static int64_t
+StorageSQLiteDistinguishedAmount()
+{
+ return ::sqlite3_memory_used();
+}
+
+/**
+ * Passes a single SQLite memory statistic to a memory reporter callback.
+ *
+ * @param aHandleReport
+ * The callback.
+ * @param aData
+ * The data for the callback.
+ * @param aConn
+ * The SQLite connection.
+ * @param aPathHead
+ * Head of the path for the memory report.
+ * @param aKind
+ * The memory report statistic kind, one of "stmt", "cache" or
+ * "schema".
+ * @param aDesc
+ * The memory report description.
+ * @param aOption
+ * The SQLite constant for getting the measurement.
+ * @param aTotal
+ * The accumulator for the measurement.
+ */
+static void
+ReportConn(nsIHandleReportCallback *aHandleReport,
+ nsISupports *aData,
+ Connection *aConn,
+ const nsACString &aPathHead,
+ const nsACString &aKind,
+ const nsACString &aDesc,
+ int32_t aOption,
+ size_t *aTotal)
+{
+ nsCString path(aPathHead);
+ path.Append(aKind);
+ path.AppendLiteral("-used");
+
+ int32_t val = aConn->getSqliteRuntimeStatus(aOption);
+ aHandleReport->Callback(EmptyCString(), path,
+ nsIMemoryReporter::KIND_HEAP,
+ nsIMemoryReporter::UNITS_BYTES,
+ int64_t(val), aDesc, aData);
+ *aTotal += val;
+}
+
+// Warning: To get a Connection's measurements requires holding its lock.
+// There may be a delay getting the lock if another thread is accessing the
+// Connection. This isn't very nice if CollectReports is called from the main
+// thread! But at the time of writing this function is only called when
+// about:memory is loaded (not, for example, when telemetry pings occur) and
+// any delays in that case aren't so bad.
+NS_IMETHODIMP
+Service::CollectReports(nsIHandleReportCallback *aHandleReport,
+ nsISupports *aData, bool aAnonymize)
+{
+ size_t totalConnSize = 0;
+ {
+ nsTArray<RefPtr<Connection> > connections;
+ getConnections(connections);
+
+ for (uint32_t i = 0; i < connections.Length(); i++) {
+ RefPtr<Connection> &conn = connections[i];
+
+ // Someone may have closed the Connection, in which case we skip it.
+ bool isReady;
+ (void)conn->GetConnectionReady(&isReady);
+ if (!isReady) {
+ continue;
+ }
+
+ nsCString pathHead("explicit/storage/sqlite/");
+ // This filename isn't privacy-sensitive, and so is never anonymized.
+ pathHead.Append(conn->getFilename());
+ pathHead.Append('/');
+
+ SQLiteMutexAutoLock lockedScope(conn->sharedDBMutex);
+
+ NS_NAMED_LITERAL_CSTRING(stmtDesc,
+ "Memory (approximate) used by all prepared statements used by "
+ "connections to this database.");
+ ReportConn(aHandleReport, aData, conn, pathHead,
+ NS_LITERAL_CSTRING("stmt"), stmtDesc,
+ SQLITE_DBSTATUS_STMT_USED, &totalConnSize);
+
+ NS_NAMED_LITERAL_CSTRING(cacheDesc,
+ "Memory (approximate) used by all pager caches used by connections "
+ "to this database.");
+ ReportConn(aHandleReport, aData, conn, pathHead,
+ NS_LITERAL_CSTRING("cache"), cacheDesc,
+ SQLITE_DBSTATUS_CACHE_USED_SHARED, &totalConnSize);
+
+ NS_NAMED_LITERAL_CSTRING(schemaDesc,
+ "Memory (approximate) used to store the schema for all databases "
+ "associated with connections to this database.");
+ ReportConn(aHandleReport, aData, conn, pathHead,
+ NS_LITERAL_CSTRING("schema"), schemaDesc,
+ SQLITE_DBSTATUS_SCHEMA_USED, &totalConnSize);
+ }
+
+#ifdef MOZ_DMD
+ if (::sqlite3_memory_used() != int64_t(gSqliteMemoryUsed)) {
+ NS_WARNING("memory consumption reported by SQLite doesn't match "
+ "our measurements");
+ }
+#endif
+ }
+
+ int64_t other = ::sqlite3_memory_used() - totalConnSize;
+
+ MOZ_COLLECT_REPORT(
+ "explicit/storage/sqlite/other", KIND_HEAP, UNITS_BYTES, other,
+ "All unclassified sqlite memory.");
+
+ return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// Service
+
+NS_IMPL_ISUPPORTS(
+ Service,
+ mozIStorageService,
+ nsIObserver,
+ nsIMemoryReporter
+)
+
+Service *Service::gService = nullptr;
+
+Service *
+Service::getSingleton()
+{
+ if (gService) {
+ NS_ADDREF(gService);
+ return gService;
+ }
+
+ // Ensure that we are using the same version of SQLite that we compiled with
+ // or newer. Our configure check ensures we are using a new enough version
+ // at compile time.
+ if (SQLITE_VERSION_NUMBER > ::sqlite3_libversion_number()) {
+ nsCOMPtr<nsIPromptService> ps(do_GetService(NS_PROMPTSERVICE_CONTRACTID));
+ if (ps) {
+ nsAutoString title, message;
+ title.AppendLiteral("SQLite Version Error");
+ message.AppendLiteral("The application has been updated, but the SQLite "
+ "library wasn't updated properly and the application "
+ "cannot run. Please try to launch the application again. "
+ "If that should still fail, please try reinstalling "
+ "it, or visit https://support.mozilla.org/.");
+ (void)ps->Alert(nullptr, title.get(), message.get());
+ }
+ MOZ_CRASH("SQLite Version Error");
+ }
+
+ // The first reference to the storage service must be obtained on the
+ // main thread.
+ NS_ENSURE_TRUE(NS_IsMainThread(), nullptr);
+ gService = new Service();
+ if (gService) {
+ NS_ADDREF(gService);
+ if (NS_FAILED(gService->initialize()))
+ NS_RELEASE(gService);
+ }
+
+ return gService;
+}
+
+nsIXPConnect *Service::sXPConnect = nullptr;
+
+// static
+already_AddRefed<nsIXPConnect>
+Service::getXPConnect()
+{
+ NS_PRECONDITION(NS_IsMainThread(),
+ "Must only get XPConnect on the main thread!");
+ NS_PRECONDITION(gService,
+ "Can not get XPConnect without an instance of our service!");
+
+ // If we've been shutdown, sXPConnect will be null. To prevent leaks, we do
+ // not cache the service after this point.
+ nsCOMPtr<nsIXPConnect> xpc(sXPConnect);
+ if (!xpc)
+ xpc = do_GetService(nsIXPConnect::GetCID());
+ NS_ASSERTION(xpc, "Could not get XPConnect!");
+ return xpc.forget();
+}
+
+int32_t Service::sSynchronousPref;
+
+// static
+int32_t
+Service::getSynchronousPref()
+{
+ return sSynchronousPref;
+}
+
+int32_t Service::sDefaultPageSize = PREF_TS_PAGESIZE_DEFAULT;
+
+Service::Service()
+: mMutex("Service::mMutex")
+, mSqliteVFS(nullptr)
+, mRegistrationMutex("Service::mRegistrationMutex")
+, mConnections()
+{
+}
+
+Service::~Service()
+{
+ mozilla::UnregisterWeakMemoryReporter(this);
+ mozilla::UnregisterStorageSQLiteDistinguishedAmount();
+
+ int rc = sqlite3_vfs_unregister(mSqliteVFS);
+ if (rc != SQLITE_OK)
+ NS_WARNING("Failed to unregister sqlite vfs wrapper.");
+
+ // Shutdown the sqlite3 API. Warn if shutdown did not turn out okay, but
+ // there is nothing actionable we can do in that case.
+ rc = ::sqlite3_shutdown();
+ if (rc != SQLITE_OK)
+ NS_WARNING("sqlite3 did not shutdown cleanly.");
+
+ DebugOnly<bool> shutdownObserved = !sXPConnect;
+ NS_ASSERTION(shutdownObserved, "Shutdown was not observed!");
+
+ gService = nullptr;
+ delete mSqliteVFS;
+ mSqliteVFS = nullptr;
+}
+
+void
+Service::registerConnection(Connection *aConnection)
+{
+ mRegistrationMutex.AssertNotCurrentThreadOwns();
+ MutexAutoLock mutex(mRegistrationMutex);
+ (void)mConnections.AppendElement(aConnection);
+}
+
+void
+Service::unregisterConnection(Connection *aConnection)
+{
+ // If this is the last Connection it might be the only thing keeping Service
+ // alive. So ensure that Service is destroyed only after the Connection is
+ // cleanly unregistered and destroyed.
+ RefPtr<Service> kungFuDeathGrip(this);
+ {
+ mRegistrationMutex.AssertNotCurrentThreadOwns();
+ MutexAutoLock mutex(mRegistrationMutex);
+
+ for (uint32_t i = 0 ; i < mConnections.Length(); ++i) {
+ if (mConnections[i] == aConnection) {
+ nsCOMPtr<nsIThread> thread = mConnections[i]->threadOpenedOn;
+
+ // Ensure the connection is released on its opening thread. Note, we
+ // must use .forget().take() so that we can manually cast to an
+ // unambiguous nsISupports type.
+ NS_ProxyRelease(thread, mConnections[i].forget());
+
+ mConnections.RemoveElementAt(i);
+ return;
+ }
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Attempt to unregister unknown storage connection!");
+ }
+}
+
+void
+Service::getConnections(/* inout */ nsTArray<RefPtr<Connection> >& aConnections)
+{
+ mRegistrationMutex.AssertNotCurrentThreadOwns();
+ MutexAutoLock mutex(mRegistrationMutex);
+ aConnections.Clear();
+ aConnections.AppendElements(mConnections);
+}
+
+void
+Service::minimizeMemory()
+{
+ nsTArray<RefPtr<Connection> > connections;
+ getConnections(connections);
+
+ for (uint32_t i = 0; i < connections.Length(); i++) {
+ RefPtr<Connection> conn = connections[i];
+ if (!conn->connectionReady())
+ continue;
+
+ NS_NAMED_LITERAL_CSTRING(shrinkPragma, "PRAGMA shrink_memory");
+ nsCOMPtr<mozIStorageConnection> syncConn = do_QueryInterface(
+ NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, conn));
+ bool onOpenedThread = false;
+
+ if (!syncConn) {
+ // This is a mozIStorageAsyncConnection, it can only be used on the main
+ // thread, so we can do a straight API call.
+ nsCOMPtr<mozIStoragePendingStatement> ps;
+ DebugOnly<nsresult> rv =
+ conn->ExecuteSimpleSQLAsync(shrinkPragma, nullptr, getter_AddRefs(ps));
+ MOZ_ASSERT(NS_SUCCEEDED(rv), "Should have purged sqlite caches");
+ } else if (NS_SUCCEEDED(conn->threadOpenedOn->IsOnCurrentThread(&onOpenedThread)) &&
+ onOpenedThread) {
+ // We are on the opener thread, so we can just proceed.
+ conn->ExecuteSimpleSQL(shrinkPragma);
+ } else {
+ // We are on the wrong thread, the query should be executed on the
+ // opener thread, so we must dispatch to it.
+ nsCOMPtr<nsIRunnable> event =
+ NewRunnableMethod<const nsCString>(
+ conn, &Connection::ExecuteSimpleSQL, shrinkPragma);
+ conn->threadOpenedOn->Dispatch(event, NS_DISPATCH_NORMAL);
+ }
+ }
+}
+
+void
+Service::shutdown()
+{
+ NS_IF_RELEASE(sXPConnect);
+}
+
+sqlite3_vfs *ConstructTelemetryVFS();
+
+#ifdef MOZ_STORAGE_MEMORY
+
+namespace {
+
+// By default, SQLite tracks the size of all its heap blocks by adding an extra
+// 8 bytes at the start of the block to hold the size. Unfortunately, this
+// causes a lot of 2^N-sized allocations to be rounded up by jemalloc
+// allocator, wasting memory. For example, a request for 1024 bytes has 8
+// bytes added, becoming a request for 1032 bytes, and jemalloc rounds this up
+// to 2048 bytes, wasting 1012 bytes. (See bug 676189 for more details.)
+//
+// So we register jemalloc as the malloc implementation, which avoids this
+// 8-byte overhead, and thus a lot of waste. This requires us to provide a
+// function, sqliteMemRoundup(), which computes the actual size that will be
+// allocated for a given request. SQLite uses this function before all
+// allocations, and may be able to use any excess bytes caused by the rounding.
+//
+// Note: the wrappers for malloc, realloc and moz_malloc_usable_size are
+// necessary because the sqlite_mem_methods type signatures differ slightly
+// from the standard ones -- they use int instead of size_t. But we don't need
+// a wrapper for free.
+
+#ifdef MOZ_DMD
+
+// sqlite does its own memory accounting, and we use its numbers in our memory
+// reporters. But we don't want sqlite's heap blocks to show up in DMD's
+// output as unreported, so we mark them as reported when they're allocated and
+// mark them as unreported when they are freed.
+//
+// In other words, we are marking all sqlite heap blocks as reported even
+// though we're not reporting them ourselves. Instead we're trusting that
+// sqlite is fully and correctly accounting for all of its heap blocks via its
+// own memory accounting. Well, we don't have to trust it entirely, because
+// it's easy to keep track (while doing this DMD-specific marking) of exactly
+// how much memory SQLite is using. And we can compare that against what
+// SQLite reports it is using.
+
+MOZ_DEFINE_MALLOC_SIZE_OF_ON_ALLOC(SqliteMallocSizeOfOnAlloc)
+MOZ_DEFINE_MALLOC_SIZE_OF_ON_FREE(SqliteMallocSizeOfOnFree)
+
+#endif
+
+static void *sqliteMemMalloc(int n)
+{
+ void* p = ::malloc(n);
+#ifdef MOZ_DMD
+ gSqliteMemoryUsed += SqliteMallocSizeOfOnAlloc(p);
+#endif
+ return p;
+}
+
+static void sqliteMemFree(void *p)
+{
+#ifdef MOZ_DMD
+ gSqliteMemoryUsed -= SqliteMallocSizeOfOnFree(p);
+#endif
+ ::free(p);
+}
+
+static void *sqliteMemRealloc(void *p, int n)
+{
+#ifdef MOZ_DMD
+ gSqliteMemoryUsed -= SqliteMallocSizeOfOnFree(p);
+ void *pnew = ::realloc(p, n);
+ if (pnew) {
+ gSqliteMemoryUsed += SqliteMallocSizeOfOnAlloc(pnew);
+ } else {
+ // realloc failed; undo the SqliteMallocSizeOfOnFree from above
+ gSqliteMemoryUsed += SqliteMallocSizeOfOnAlloc(p);
+ }
+ return pnew;
+#else
+ return ::realloc(p, n);
+#endif
+}
+
+static int sqliteMemSize(void *p)
+{
+ return ::moz_malloc_usable_size(p);
+}
+
+static int sqliteMemRoundup(int n)
+{
+ n = malloc_good_size(n);
+
+ // jemalloc can return blocks of size 2 and 4, but SQLite requires that all
+ // allocations be 8-aligned. So we round up sub-8 requests to 8. This
+ // wastes a small amount of memory but is obviously safe.
+ return n <= 8 ? 8 : n;
+}
+
+static int sqliteMemInit(void *p)
+{
+ return 0;
+}
+
+static void sqliteMemShutdown(void *p)
+{
+}
+
+const sqlite3_mem_methods memMethods = {
+ &sqliteMemMalloc,
+ &sqliteMemFree,
+ &sqliteMemRealloc,
+ &sqliteMemSize,
+ &sqliteMemRoundup,
+ &sqliteMemInit,
+ &sqliteMemShutdown,
+ nullptr
+};
+
+} // namespace
+
+#endif // MOZ_STORAGE_MEMORY
+
+static const char* sObserverTopics[] = {
+ "memory-pressure",
+ "xpcom-shutdown",
+ "xpcom-shutdown-threads"
+};
+
+nsresult
+Service::initialize()
+{
+ MOZ_ASSERT(NS_IsMainThread(), "Must be initialized on the main thread");
+
+ int rc;
+
+#ifdef MOZ_STORAGE_MEMORY
+ rc = ::sqlite3_config(SQLITE_CONFIG_MALLOC, &memMethods);
+ if (rc != SQLITE_OK)
+ return convertResultCode(rc);
+#endif
+
+ // TODO (bug 1191405): do not preallocate the connections caches until we
+ // have figured the impact on our consumers and memory.
+ sqlite3_config(SQLITE_CONFIG_PAGECACHE, NULL, 0, 0);
+
+ // Explicitly initialize sqlite3. Although this is implicitly called by
+ // various sqlite3 functions (and the sqlite3_open calls in our case),
+ // the documentation suggests calling this directly. So we do.
+ rc = ::sqlite3_initialize();
+ if (rc != SQLITE_OK)
+ return convertResultCode(rc);
+
+ mSqliteVFS = ConstructTelemetryVFS();
+ if (mSqliteVFS) {
+ rc = sqlite3_vfs_register(mSqliteVFS, 1);
+ if (rc != SQLITE_OK)
+ return convertResultCode(rc);
+ } else {
+ NS_WARNING("Failed to register telemetry VFS");
+ }
+
+ // Register for xpcom-shutdown so we can cleanup after ourselves. The
+ // observer service can only be used on the main thread.
+ nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+ NS_ENSURE_TRUE(os, NS_ERROR_FAILURE);
+
+ for (size_t i = 0; i < ArrayLength(sObserverTopics); ++i) {
+ nsresult rv = os->AddObserver(this, sObserverTopics[i], false);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ }
+
+ // We cache XPConnect for our language helpers. XPConnect can only be
+ // used on the main thread.
+ (void)CallGetService(nsIXPConnect::GetCID(), &sXPConnect);
+
+ // We need to obtain the toolkit.storage.synchronous preferences on the main
+ // thread because the preference service can only be accessed there. This
+ // is cached in the service for all future Open[Unshared]Database calls.
+ sSynchronousPref =
+ Preferences::GetInt(PREF_TS_SYNCHRONOUS, PREF_TS_SYNCHRONOUS_DEFAULT);
+
+ // We need to obtain the toolkit.storage.pageSize preferences on the main
+ // thread because the preference service can only be accessed there. This
+ // is cached in the service for all future Open[Unshared]Database calls.
+ sDefaultPageSize =
+ Preferences::GetInt(PREF_TS_PAGESIZE, PREF_TS_PAGESIZE_DEFAULT);
+
+ mozilla::RegisterWeakMemoryReporter(this);
+ mozilla::RegisterStorageSQLiteDistinguishedAmount(StorageSQLiteDistinguishedAmount);
+
+ return NS_OK;
+}
+
+int
+Service::localeCompareStrings(const nsAString &aStr1,
+ const nsAString &aStr2,
+ int32_t aComparisonStrength)
+{
+ // The implementation of nsICollation.CompareString() is platform-dependent.
+ // On Linux it's not thread-safe. It may not be on Windows and OS X either,
+ // but it's more difficult to tell. We therefore synchronize this method.
+ MutexAutoLock mutex(mMutex);
+
+ nsICollation *coll = getLocaleCollation();
+ if (!coll) {
+ NS_ERROR("Storage service has no collation");
+ return 0;
+ }
+
+ int32_t res;
+ nsresult rv = coll->CompareString(aComparisonStrength, aStr1, aStr2, &res);
+ if (NS_FAILED(rv)) {
+ NS_ERROR("Collation compare string failed");
+ return 0;
+ }
+
+ return res;
+}
+
+nsICollation *
+Service::getLocaleCollation()
+{
+ mMutex.AssertCurrentThreadOwns();
+
+ if (mLocaleCollation)
+ return mLocaleCollation;
+
+ nsCOMPtr<nsILocaleService> svc(do_GetService(NS_LOCALESERVICE_CONTRACTID));
+ if (!svc) {
+ NS_WARNING("Could not get locale service");
+ return nullptr;
+ }
+
+ nsCOMPtr<nsILocale> appLocale;
+ nsresult rv = svc->GetApplicationLocale(getter_AddRefs(appLocale));
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Could not get application locale");
+ return nullptr;
+ }
+
+ nsCOMPtr<nsICollationFactory> collFact =
+ do_CreateInstance(NS_COLLATIONFACTORY_CONTRACTID);
+ if (!collFact) {
+ NS_WARNING("Could not create collation factory");
+ return nullptr;
+ }
+
+ rv = collFact->CreateCollation(appLocale, getter_AddRefs(mLocaleCollation));
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Could not create collation");
+ return nullptr;
+ }
+
+ return mLocaleCollation;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// mozIStorageService
+
+
+NS_IMETHODIMP
+Service::OpenSpecialDatabase(const char *aStorageKey,
+ mozIStorageConnection **_connection)
+{
+ nsresult rv;
+
+ nsCOMPtr<nsIFile> storageFile;
+ if (::strcmp(aStorageKey, "memory") == 0) {
+ // just fall through with nullptr storageFile, this will cause the storage
+ // connection to use a memory DB.
+ }
+ else {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ RefPtr<Connection> msc = new Connection(this, SQLITE_OPEN_READWRITE, false);
+
+ rv = storageFile ? msc->initialize(storageFile) : msc->initialize();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ msc.forget(_connection);
+ return NS_OK;
+
+}
+
+namespace {
+
+class AsyncInitDatabase final : public Runnable
+{
+public:
+ AsyncInitDatabase(Connection* aConnection,
+ nsIFile* aStorageFile,
+ int32_t aGrowthIncrement,
+ mozIStorageCompletionCallback* aCallback)
+ : mConnection(aConnection)
+ , mStorageFile(aStorageFile)
+ , mGrowthIncrement(aGrowthIncrement)
+ , mCallback(aCallback)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+
+ NS_IMETHOD Run() override
+ {
+ MOZ_ASSERT(!NS_IsMainThread());
+ nsresult rv = mStorageFile ? mConnection->initialize(mStorageFile)
+ : mConnection->initialize();
+ if (NS_FAILED(rv)) {
+ nsCOMPtr<nsIRunnable> closeRunnable =
+ NewRunnableMethod<mozIStorageCompletionCallback*>(
+ mConnection.get(),
+ &Connection::AsyncClose,
+ nullptr);
+ MOZ_ASSERT(closeRunnable);
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(closeRunnable));
+
+ return DispatchResult(rv, nullptr);
+ }
+
+ if (mGrowthIncrement >= 0) {
+ // Ignore errors. In the future, we might wish to log them.
+ (void)mConnection->SetGrowthIncrement(mGrowthIncrement, EmptyCString());
+ }
+
+ return DispatchResult(NS_OK, NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*,
+ mConnection));
+ }
+
+private:
+ nsresult DispatchResult(nsresult aStatus, nsISupports* aValue) {
+ RefPtr<CallbackComplete> event =
+ new CallbackComplete(aStatus,
+ aValue,
+ mCallback.forget());
+ return NS_DispatchToMainThread(event);
+ }
+
+ ~AsyncInitDatabase()
+ {
+ NS_ReleaseOnMainThread(mStorageFile.forget());
+ NS_ReleaseOnMainThread(mConnection.forget());
+
+ // Generally, the callback will be released by CallbackComplete.
+ // However, if for some reason Run() is not executed, we still
+ // need to ensure that it is released here.
+ NS_ReleaseOnMainThread(mCallback.forget());
+ }
+
+ RefPtr<Connection> mConnection;
+ nsCOMPtr<nsIFile> mStorageFile;
+ int32_t mGrowthIncrement;
+ RefPtr<mozIStorageCompletionCallback> mCallback;
+};
+
+} // namespace
+
+NS_IMETHODIMP
+Service::OpenAsyncDatabase(nsIVariant *aDatabaseStore,
+ nsIPropertyBag2 *aOptions,
+ mozIStorageCompletionCallback *aCallback)
+{
+ if (!NS_IsMainThread()) {
+ return NS_ERROR_NOT_SAME_THREAD;
+ }
+ NS_ENSURE_ARG(aDatabaseStore);
+ NS_ENSURE_ARG(aCallback);
+
+ nsresult rv;
+ bool shared = false;
+ bool readOnly = false;
+ bool ignoreLockingMode = false;
+ int32_t growthIncrement = -1;
+
+#define FAIL_IF_SET_BUT_INVALID(rv)\
+ if (NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE) { \
+ return NS_ERROR_INVALID_ARG; \
+ }
+
+ // Deal with options first:
+ if (aOptions) {
+ rv = aOptions->GetPropertyAsBool(NS_LITERAL_STRING("readOnly"), &readOnly);
+ FAIL_IF_SET_BUT_INVALID(rv);
+
+ rv = aOptions->GetPropertyAsBool(NS_LITERAL_STRING("ignoreLockingMode"),
+ &ignoreLockingMode);
+ FAIL_IF_SET_BUT_INVALID(rv);
+ // Specifying ignoreLockingMode will force use of the readOnly flag:
+ if (ignoreLockingMode) {
+ readOnly = true;
+ }
+
+ rv = aOptions->GetPropertyAsBool(NS_LITERAL_STRING("shared"), &shared);
+ FAIL_IF_SET_BUT_INVALID(rv);
+
+ // NB: we re-set to -1 if we don't have a storage file later on.
+ rv = aOptions->GetPropertyAsInt32(NS_LITERAL_STRING("growthIncrement"),
+ &growthIncrement);
+ FAIL_IF_SET_BUT_INVALID(rv);
+ }
+ int flags = readOnly ? SQLITE_OPEN_READONLY : SQLITE_OPEN_READWRITE;
+
+ nsCOMPtr<nsIFile> storageFile;
+ nsCOMPtr<nsISupports> dbStore;
+ rv = aDatabaseStore->GetAsISupports(getter_AddRefs(dbStore));
+ if (NS_SUCCEEDED(rv)) {
+ // Generally, aDatabaseStore holds the database nsIFile.
+ storageFile = do_QueryInterface(dbStore, &rv);
+ if (NS_FAILED(rv)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ rv = storageFile->Clone(getter_AddRefs(storageFile));
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+ if (!readOnly) {
+ // Ensure that SQLITE_OPEN_CREATE is passed in for compatibility reasons.
+ flags |= SQLITE_OPEN_CREATE;
+ }
+
+ // Apply the shared-cache option.
+ flags |= shared ? SQLITE_OPEN_SHAREDCACHE : SQLITE_OPEN_PRIVATECACHE;
+ } else {
+ // Sometimes, however, it's a special database name.
+ nsAutoCString keyString;
+ rv = aDatabaseStore->GetAsACString(keyString);
+ if (NS_FAILED(rv) || !keyString.EqualsLiteral("memory")) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Just fall through with nullptr storageFile, this will cause the storage
+ // connection to use a memory DB.
+ }
+
+ if (!storageFile && growthIncrement >= 0) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Create connection on this thread, but initialize it on its helper thread.
+ RefPtr<Connection> msc = new Connection(this, flags, true,
+ ignoreLockingMode);
+ nsCOMPtr<nsIEventTarget> target = msc->getAsyncExecutionTarget();
+ MOZ_ASSERT(target, "Cannot initialize a connection that has been closed already");
+
+ RefPtr<AsyncInitDatabase> asyncInit =
+ new AsyncInitDatabase(msc,
+ storageFile,
+ growthIncrement,
+ aCallback);
+ return target->Dispatch(asyncInit, nsIEventTarget::DISPATCH_NORMAL);
+}
+
+NS_IMETHODIMP
+Service::OpenDatabase(nsIFile *aDatabaseFile,
+ mozIStorageConnection **_connection)
+{
+ NS_ENSURE_ARG(aDatabaseFile);
+
+ // Always ensure that SQLITE_OPEN_CREATE is passed in for compatibility
+ // reasons.
+ int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_SHAREDCACHE |
+ SQLITE_OPEN_CREATE;
+ RefPtr<Connection> msc = new Connection(this, flags, false);
+
+ nsresult rv = msc->initialize(aDatabaseFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ msc.forget(_connection);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+Service::OpenUnsharedDatabase(nsIFile *aDatabaseFile,
+ mozIStorageConnection **_connection)
+{
+ NS_ENSURE_ARG(aDatabaseFile);
+
+ // Always ensure that SQLITE_OPEN_CREATE is passed in for compatibility
+ // reasons.
+ int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_PRIVATECACHE |
+ SQLITE_OPEN_CREATE;
+ RefPtr<Connection> msc = new Connection(this, flags, false);
+
+ nsresult rv = msc->initialize(aDatabaseFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ msc.forget(_connection);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+Service::OpenDatabaseWithFileURL(nsIFileURL *aFileURL,
+ mozIStorageConnection **_connection)
+{
+ NS_ENSURE_ARG(aFileURL);
+
+ // Always ensure that SQLITE_OPEN_CREATE is passed in for compatibility
+ // reasons.
+ int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_SHAREDCACHE |
+ SQLITE_OPEN_CREATE | SQLITE_OPEN_URI;
+ RefPtr<Connection> msc = new Connection(this, flags, false);
+
+ nsresult rv = msc->initialize(aFileURL);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ msc.forget(_connection);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+Service::BackupDatabaseFile(nsIFile *aDBFile,
+ const nsAString &aBackupFileName,
+ nsIFile *aBackupParentDirectory,
+ nsIFile **backup)
+{
+ nsresult rv;
+ nsCOMPtr<nsIFile> parentDir = aBackupParentDirectory;
+ if (!parentDir) {
+ // This argument is optional, and defaults to the same parent directory
+ // as the current file.
+ rv = aDBFile->GetParent(getter_AddRefs(parentDir));
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ nsCOMPtr<nsIFile> backupDB;
+ rv = parentDir->Clone(getter_AddRefs(backupDB));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = backupDB->Append(aBackupFileName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = backupDB->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsAutoString fileName;
+ rv = backupDB->GetLeafName(fileName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = backupDB->Remove(false);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ backupDB.forget(backup);
+
+ return aDBFile->CopyTo(parentDir, fileName);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIObserver
+
+NS_IMETHODIMP
+Service::Observe(nsISupports *, const char *aTopic, const char16_t *)
+{
+ if (strcmp(aTopic, "memory-pressure") == 0) {
+ minimizeMemory();
+ } else if (strcmp(aTopic, "xpcom-shutdown") == 0) {
+ shutdown();
+ } else if (strcmp(aTopic, "xpcom-shutdown-threads") == 0) {
+ nsCOMPtr<nsIObserverService> os =
+ mozilla::services::GetObserverService();
+
+ for (size_t i = 0; i < ArrayLength(sObserverTopics); ++i) {
+ (void)os->RemoveObserver(this, sObserverTopics[i]);
+ }
+
+ bool anyOpen = false;
+ do {
+ nsTArray<RefPtr<Connection> > connections;
+ getConnections(connections);
+ anyOpen = false;
+ for (uint32_t i = 0; i < connections.Length(); i++) {
+ RefPtr<Connection> &conn = connections[i];
+ if (conn->isClosing()) {
+ anyOpen = true;
+ break;
+ }
+ }
+ if (anyOpen) {
+ nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
+ NS_ProcessNextEvent(thread);
+ }
+ } while (anyOpen);
+
+ if (gShutdownChecks == SCM_CRASH) {
+ nsTArray<RefPtr<Connection> > connections;
+ getConnections(connections);
+ for (uint32_t i = 0, n = connections.Length(); i < n; i++) {
+ if (!connections[i]->isClosed()) {
+ MOZ_CRASH();
+ }
+ }
+ }
+ }
+
+ return NS_OK;
+}
+
+} // namespace storage
+} // namespace mozilla