storage/mozStorageConnection.cpp

   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 #include "BaseVFS.h"
   8 #include "ErrorList.h"
   9 #include "nsError.h"
  10 #include "nsThreadUtils.h"
  11 #include "nsIFile.h"
  12 #include "nsIFileURL.h"
  13 #include "nsIXPConnect.h"
  14 #include "mozilla/AppShutdown.h"
  15 #include "mozilla/CheckedInt.h"
  16 #include "mozilla/Telemetry.h"
  17 #include "mozilla/Mutex.h"
  18 #include "mozilla/CondVar.h"
  19 #include "mozilla/Attributes.h"
  20 #include "mozilla/ErrorNames.h"
  21 #include "mozilla/Unused.h"
  22 #include "mozilla/dom/quota/QuotaObject.h"
  23 #include "mozilla/ScopeExit.h"
  24 #include "mozilla/SpinEventLoopUntil.h"
  25 #include "mozilla/StaticPrefs_storage.h"
  26
  27 #include "mozIStorageCompletionCallback.h"
  28 #include "mozIStorageFunction.h"
  29
  30 #include "mozStorageAsyncStatementExecution.h"
  31 #include "mozStorageSQLFunctions.h"
  32 #include "mozStorageConnection.h"
  33 #include "mozStorageService.h"
  34 #include "mozStorageStatement.h"
  35 #include "mozStorageAsyncStatement.h"
  36 #include "mozStorageArgValueArray.h"
  37 #include "mozStoragePrivateHelpers.h"
  38 #include "mozStorageStatementData.h"
  39 #include "ObfuscatingVFS.h"
  40 #include "QuotaVFS.h"
  41 #include "StorageBaseStatementInternal.h"
  42 #include "SQLCollations.h"
  43 #include "FileSystemModule.h"
  44 #include "mozStorageHelper.h"
  45
  46 #include "mozilla/Assertions.h"
  47 #include "mozilla/Logging.h"
  48 #include "mozilla/Printf.h"
  49 #include "mozilla/ProfilerLabels.h"
  50 #include "mozilla/RefPtr.h"
  51 #include "nsComponentManagerUtils.h"
  52 #include "nsProxyRelease.h"
  53 #include "nsStringFwd.h"
  54 #include "nsURLHelper.h"
  55
  56 #define MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH 524288000  // 500 MiB
  57
  58 // Maximum size of the pages cache per connection.
  59 #define MAX_CACHE_SIZE_KIBIBYTES 2048  // 2 MiB
  60
  61 mozilla::LazyLogModule gStorageLog("mozStorage");
  62
  63 // Checks that the protected code is running on the main-thread only if the
  64 // connection was also opened on it.
  65 #ifdef DEBUG
  66 #  define CHECK_MAINTHREAD_ABUSE()                                   \
  67     do {                                                             \
  68       NS_WARNING_ASSERTION(                                          \
  69           eventTargetOpenedOn == GetMainThreadSerialEventTarget() || \
  70               !NS_IsMainThread(),                                    \
  71           "Using Storage synchronous API on main-thread, but "       \
  72           "the connection was opened on another thread.");           \
  73     } while (0)
  74 #else
  75 #  define CHECK_MAINTHREAD_ABUSE() \
  76     do { /* Nothing */             \
  77     } while (0)
  78 #endif
  79
  80 namespace mozilla::storage {
  81
  82 using mozilla::dom::quota::QuotaObject;
  83 using mozilla::Telemetry::AccumulateCategoricalKeyed;
  84 using mozilla::Telemetry::LABELS_SQLITE_STORE_OPEN;
  85 using mozilla::Telemetry::LABELS_SQLITE_STORE_QUERY;
  86
  87 namespace {
  88
  89 int nsresultToSQLiteResult(nsresult aXPCOMResultCode) {
  90   if (NS_SUCCEEDED(aXPCOMResultCode)) {
  91     return SQLITE_OK;
  92   }
  93
  94   switch (aXPCOMResultCode) {
  95     case NS_ERROR_FILE_CORRUPTED:
  96       return SQLITE_CORRUPT;
  97     case NS_ERROR_FILE_ACCESS_DENIED:
  98       return SQLITE_CANTOPEN;
  99     case NS_ERROR_STORAGE_BUSY:
 100       return SQLITE_BUSY;
 101     case NS_ERROR_FILE_IS_LOCKED:
 102       return SQLITE_LOCKED;
 103     case NS_ERROR_FILE_READ_ONLY:
 104       return SQLITE_READONLY;
 105     case NS_ERROR_STORAGE_IOERR:
 106       return SQLITE_IOERR;
 107     case NS_ERROR_FILE_NO_DEVICE_SPACE:
 108       return SQLITE_FULL;
 109     case NS_ERROR_OUT_OF_MEMORY:
 110       return SQLITE_NOMEM;
 111     case NS_ERROR_UNEXPECTED:
 112       return SQLITE_MISUSE;
 113     case NS_ERROR_ABORT:
 114       return SQLITE_ABORT;
 115     case NS_ERROR_STORAGE_CONSTRAINT:
 116       return SQLITE_CONSTRAINT;
 117     default:
 118       return SQLITE_ERROR;
 119   }
 120
 121   MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Must return in switch above!");
 122 }
 123
 124 ////////////////////////////////////////////////////////////////////////////////
 125 //// Variant Specialization Functions (variantToSQLiteT)
 126
 127 int sqlite3_T_int(sqlite3_context* aCtx, int aValue) {
 128   ::sqlite3_result_int(aCtx, aValue);
 129   return SQLITE_OK;
 130 }
 131
 132 int sqlite3_T_int64(sqlite3_context* aCtx, sqlite3_int64 aValue) {
 133   ::sqlite3_result_int64(aCtx, aValue);
 134   return SQLITE_OK;
 135 }
 136
 137 int sqlite3_T_double(sqlite3_context* aCtx, double aValue) {
 138   ::sqlite3_result_double(aCtx, aValue);
 139   return SQLITE_OK;
 140 }
 141
 142 int sqlite3_T_text(sqlite3_context* aCtx, const nsCString& aValue) {
 143   CheckedInt<int32_t> length(aValue.Length());
 144   if (!length.isValid()) {
 145     return SQLITE_MISUSE;
 146   }
 147   ::sqlite3_result_text(aCtx, aValue.get(), length.value(), SQLITE_TRANSIENT);
 148   return SQLITE_OK;
 149 }
 150
 151 int sqlite3_T_text16(sqlite3_context* aCtx, const nsString& aValue) {
 152   CheckedInt<int32_t> n_bytes =
 153       CheckedInt<int32_t>(aValue.Length()) * sizeof(char16_t);
 154   if (!n_bytes.isValid()) {
 155     return SQLITE_MISUSE;
 156   }
 157   ::sqlite3_result_text16(aCtx, aValue.get(), n_bytes.value(),
 158                           SQLITE_TRANSIENT);
 159   return SQLITE_OK;
 160 }
 161
 162 int sqlite3_T_null(sqlite3_context* aCtx) {
 163   ::sqlite3_result_null(aCtx);
 164   return SQLITE_OK;
 165 }
 166
 167 int sqlite3_T_blob(sqlite3_context* aCtx, const void* aData, int aSize) {
 168   ::sqlite3_result_blob(aCtx, aData, aSize, free);
 169   return SQLITE_OK;
 170 }
 171
 172 #include "variantToSQLiteT_impl.h"
 173
 174 ////////////////////////////////////////////////////////////////////////////////
 175 //// Modules
 176
 177 struct Module {
 178   const char* name;
 179   int (*registerFunc)(sqlite3*, const char*);
 180 };
 181
 182 Module gModules[] = {{"filesystem", RegisterFileSystemModule}};
 183
 184 ////////////////////////////////////////////////////////////////////////////////
 185 //// Local Functions
 186
 187 int tracefunc(unsigned aReason, void* aClosure, void* aP, void* aX) {
 188   switch (aReason) {
 189     case SQLITE_TRACE_STMT: {
 190       // aP is a pointer to the prepared statement.
 191       sqlite3_stmt* stmt = static_cast<sqlite3_stmt*>(aP);
 192       // aX is a pointer to a string containing the unexpanded SQL or a comment,
 193       // starting with "--"" in case of a trigger.
 194       char* expanded = static_cast<char*>(aX);
 195       // Simulate what sqlite_trace was doing.
 196       if (!::strncmp(expanded, "--", 2)) {
 197         MOZ_LOG(gStorageLog, LogLevel::Debug,
 198                 ("TRACE_STMT on %p: '%s'", aClosure, expanded));
 199       } else {
 200         char* sql = ::sqlite3_expanded_sql(stmt);
 201         MOZ_LOG(gStorageLog, LogLevel::Debug,
 202                 ("TRACE_STMT on %p: '%s'", aClosure, sql));
 203         ::sqlite3_free(sql);
 204       }
 205       break;
 206     }
 207     case SQLITE_TRACE_PROFILE: {
 208       // aX is pointer to a 64bit integer containing nanoseconds it took to
 209       // execute the last command.
 210       sqlite_int64 time = *(static_cast<sqlite_int64*>(aX)) / 1000000;
 211       if (time > 0) {
 212         MOZ_LOG(gStorageLog, LogLevel::Debug,
 213                 ("TRACE_TIME on %p: %lldms", aClosure, time));
 214       }
 215       break;
 216     }
 217   }
 218   return 0;
 219 }
 220
 221 void basicFunctionHelper(sqlite3_context* aCtx, int aArgc,
 222                          sqlite3_value** aArgv) {
 223   void* userData = ::sqlite3_user_data(aCtx);
 224
 225   mozIStorageFunction* func = static_cast<mozIStorageFunction*>(userData);
 226
 227   RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv));
 228   if (!arguments) return;
 229
 230   nsCOMPtr<nsIVariant> result;
 231   nsresult rv = func->OnFunctionCall(arguments, getter_AddRefs(result));
 232   if (NS_FAILED(rv)) {
 233     nsAutoCString errorMessage;
 234     GetErrorName(rv, errorMessage);
 235     errorMessage.InsertLiteral("User function returned ", 0);
 236     errorMessage.Append('!');
 237
 238     NS_WARNING(errorMessage.get());
 239
 240     ::sqlite3_result_error(aCtx, errorMessage.get(), -1);
 241     ::sqlite3_result_error_code(aCtx, nsresultToSQLiteResult(rv));
 242     return;
 243   }
 244   int retcode = variantToSQLiteT(aCtx, result);
 245   if (retcode != SQLITE_OK) {
 246     NS_WARNING("User function returned invalid data type!");
 247     ::sqlite3_result_error(aCtx, "User function returned invalid data type",
 248                            -1);
 249   }
 250 }
 251
 252 RefPtr<QuotaObject> GetQuotaObject(sqlite3_file* aFile, bool obfuscatingVFS) {
 253   return obfuscatingVFS
 254              ? mozilla::storage::obfsvfs::GetQuotaObjectForFile(aFile)
 255              : mozilla::storage::quotavfs::GetQuotaObjectForFile(aFile);
 256 }
 257
 258 /**
 259  * This code is heavily based on the sample at:
 260  *   http://www.sqlite.org/unlock_notify.html
 261  */
 262 class UnlockNotification {
 263  public:
 264   UnlockNotification()
 265       : mMutex("UnlockNotification mMutex"),
 266         mCondVar(mMutex, "UnlockNotification condVar"),
 267         mSignaled(false) {}
 268
 269   void Wait() {
 270     MutexAutoLock lock(mMutex);
 271     while (!mSignaled) {
 272       (void)mCondVar.Wait();
 273     }
 274   }
 275
 276   void Signal() {
 277     MutexAutoLock lock(mMutex);
 278     mSignaled = true;
 279     (void)mCondVar.Notify();
 280   }
 281
 282  private:
 283   Mutex mMutex MOZ_UNANNOTATED;
 284   CondVar mCondVar;
 285   bool mSignaled;
 286 };
 287
 288 void UnlockNotifyCallback(void** aArgs, int aArgsSize) {
 289   for (int i = 0; i < aArgsSize; i++) {
 290     UnlockNotification* notification =
 291         static_cast<UnlockNotification*>(aArgs[i]);
 292     notification->Signal();
 293   }
 294 }
 295
 296 int WaitForUnlockNotify(sqlite3* aDatabase) {
 297   UnlockNotification notification;
 298   int srv =
 299       ::sqlite3_unlock_notify(aDatabase, UnlockNotifyCallback, &notification);
 300   MOZ_ASSERT(srv == SQLITE_LOCKED || srv == SQLITE_OK);
 301   if (srv == SQLITE_OK) {
 302     notification.Wait();
 303   }
 304
 305   return srv;
 306 }
 307
 308 ////////////////////////////////////////////////////////////////////////////////
 309 //// Local Classes
 310
 311 class AsyncCloseConnection final : public Runnable {
 312  public:
 313   AsyncCloseConnection(Connection* aConnection, sqlite3* aNativeConnection,
 314                        nsIRunnable* aCallbackEvent)
 315       : Runnable("storage::AsyncCloseConnection"),
 316         mConnection(aConnection),
 317         mNativeConnection(aNativeConnection),
 318         mCallbackEvent(aCallbackEvent) {}
 319
 320   NS_IMETHOD Run() override {
 321     // Make sure we don't dispatch to the current thread.
 322     MOZ_ASSERT(!IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn));
 323
 324     nsCOMPtr<nsIRunnable> event =
 325         NewRunnableMethod("storage::Connection::shutdownAsyncThread",
 326                           mConnection, &Connection::shutdownAsyncThread);
 327     MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(event));
 328
 329     // Internal close.
 330     (void)mConnection->internalClose(mNativeConnection);
 331
 332     // Callback
 333     if (mCallbackEvent) {
 334       nsCOMPtr<nsIThread> thread;
 335       (void)NS_GetMainThread(getter_AddRefs(thread));
 336       (void)thread->Dispatch(mCallbackEvent, NS_DISPATCH_NORMAL);
 337     }
 338
 339     return NS_OK;
 340   }
 341
 342   ~AsyncCloseConnection() override {
 343     NS_ReleaseOnMainThread("AsyncCloseConnection::mConnection",
 344                            mConnection.forget());
 345     NS_ReleaseOnMainThread("AsyncCloseConnection::mCallbackEvent",
 346                            mCallbackEvent.forget());
 347   }
 348
 349  private:
 350   RefPtr<Connection> mConnection;
 351   sqlite3* mNativeConnection;
 352   nsCOMPtr<nsIRunnable> mCallbackEvent;
 353 };
 354
 355 /**
 356  * An event used to initialize the clone of a connection.
 357  *
 358  * Must be executed on the clone's async execution thread.
 359  */
 360 class AsyncInitializeClone final : public Runnable {
 361  public:
 362   /**
 363    * @param aConnection The connection being cloned.
 364    * @param aClone The clone.
 365    * @param aReadOnly If |true|, the clone is read only.
 366    * @param aCallback A callback to trigger once initialization
 367    *                  is complete. This event will be called on
 368    *                  aClone->eventTargetOpenedOn.
 369    */
 370   AsyncInitializeClone(Connection* aConnection, Connection* aClone,
 371                        const bool aReadOnly,
 372                        mozIStorageCompletionCallback* aCallback)
 373       : Runnable("storage::AsyncInitializeClone"),
 374         mConnection(aConnection),
 375         mClone(aClone),
 376         mReadOnly(aReadOnly),
 377         mCallback(aCallback) {
 378     MOZ_ASSERT(NS_IsMainThread());
 379   }
 380
 381   NS_IMETHOD Run() override {
 382     MOZ_ASSERT(!NS_IsMainThread());
 383     nsresult rv = mConnection->initializeClone(mClone, mReadOnly);
 384     if (NS_FAILED(rv)) {
 385       return Dispatch(rv, nullptr);
 386     }
 387     return Dispatch(NS_OK,
 388                     NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, mClone));
 389   }
 390
 391  private:
 392   nsresult Dispatch(nsresult aResult, nsISupports* aValue) {
 393     RefPtr<CallbackComplete> event =
 394         new CallbackComplete(aResult, aValue, mCallback.forget());
 395     return mClone->eventTargetOpenedOn->Dispatch(event, NS_DISPATCH_NORMAL);
 396   }
 397
 398   ~AsyncInitializeClone() override {
 399     nsCOMPtr<nsIThread> thread;
 400     DebugOnly<nsresult> rv = NS_GetMainThread(getter_AddRefs(thread));
 401     MOZ_ASSERT(NS_SUCCEEDED(rv));
 402
 403     // Handle ambiguous nsISupports inheritance.
 404     NS_ProxyRelease("AsyncInitializeClone::mConnection", thread,
 405                     mConnection.forget());
 406     NS_ProxyRelease("AsyncInitializeClone::mClone", thread, mClone.forget());
 407
 408     // Generally, the callback will be released by CallbackComplete.
 409     // However, if for some reason Run() is not executed, we still
 410     // need to ensure that it is released here.
 411     NS_ProxyRelease("AsyncInitializeClone::mCallback", thread,
 412                     mCallback.forget());
 413   }
 414
 415   RefPtr<Connection> mConnection;
 416   RefPtr<Connection> mClone;
 417   const bool mReadOnly;
 418   nsCOMPtr<mozIStorageCompletionCallback> mCallback;
 419 };
 420
 421 /**
 422  * A listener for async connection closing.
 423  */
 424 class CloseListener final : public mozIStorageCompletionCallback {
 425  public:
 426   NS_DECL_ISUPPORTS
 427   CloseListener() : mClosed(false) {}
 428
 429   NS_IMETHOD Complete(nsresult, nsISupports*) override {
 430     mClosed = true;
 431     return NS_OK;
 432   }
 433
 434   bool mClosed;
 435
 436  private:
 437   ~CloseListener() = default;
 438 };
 439
 440 NS_IMPL_ISUPPORTS(CloseListener, mozIStorageCompletionCallback)
 441
 442 class AsyncVacuumEvent final : public Runnable {
 443  public:
 444   AsyncVacuumEvent(Connection* aConnection,
 445                    mozIStorageCompletionCallback* aCallback,
 446                    bool aUseIncremental, int32_t aSetPageSize)
 447       : Runnable("storage::AsyncVacuum"),
 448         mConnection(aConnection),
 449         mCallback(aCallback),
 450         mUseIncremental(aUseIncremental),
 451         mSetPageSize(aSetPageSize),
 452         mStatus(NS_ERROR_UNEXPECTED) {}
 453
 454   NS_IMETHOD Run() override {
 455     // This is initially dispatched to the helper thread, then re-dispatched
 456     // to the opener thread, where it will callback.
 457     if (IsOnCurrentSerialEventTarget(mConnection->eventTargetOpenedOn)) {
 458       // Send the completion event.
 459       if (mCallback) {
 460         mozilla::Unused << mCallback->Complete(mStatus, nullptr);
 461       }
 462       return NS_OK;
 463     }
 464
 465     // Ensure to invoke the callback regardless of errors.
 466     auto guard = MakeScopeExit([&]() {
 467       mConnection->mIsStatementOnHelperThreadInterruptible = false;
 468       mozilla::Unused << mConnection->eventTargetOpenedOn->Dispatch(
 469           this, NS_DISPATCH_NORMAL);
 470     });
 471
 472     // Get list of attached databases.
 473     nsCOMPtr<mozIStorageStatement> stmt;
 474     nsresult rv = mConnection->CreateStatement(MOZ_STORAGE_UNIQUIFY_QUERY_STR
 475                                                "PRAGMA database_list"_ns,
 476                                                getter_AddRefs(stmt));
 477     NS_ENSURE_SUCCESS(rv, rv);
 478     // We must accumulate names and loop through them later, otherwise VACUUM
 479     // will see an ongoing statement and bail out.
 480     nsTArray<nsCString> schemaNames;
 481     bool hasResult = false;
 482     while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
 483       nsAutoCString name;
 484       rv = stmt->GetUTF8String(1, name);
 485       if (NS_SUCCEEDED(rv) && !name.EqualsLiteral("temp")) {
 486         schemaNames.AppendElement(name);
 487       }
 488     }
 489     mStatus = NS_OK;
 490     // Mark this vacuum as an interruptible operation, so it can be interrupted
 491     // if the connection closes during shutdown.
 492     mConnection->mIsStatementOnHelperThreadInterruptible = true;
 493     for (const nsCString& schemaName : schemaNames) {
 494       rv = this->Vacuum(schemaName);
 495       if (NS_FAILED(rv)) {
 496         // This is sub-optimal since it's only keeping the last error reason,
 497         // but it will do for now.
 498         mStatus = rv;
 499       }
 500     }
 501     return mStatus;
 502   }
 503
 504   nsresult Vacuum(const nsACString& aSchemaName) {
 505     // Abort if we're in shutdown.
 506     if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
 507       return NS_ERROR_ABORT;
 508     }
 509     int32_t removablePages = mConnection->RemovablePagesInFreeList(aSchemaName);
 510     if (!removablePages) {
 511       // There's no empty pages to remove, so skip this vacuum for now.
 512       return NS_OK;
 513     }
 514     nsresult rv;
 515     bool needsFullVacuum = true;
 516
 517     if (mSetPageSize) {
 518       nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
 519       query.Append(aSchemaName);
 520       query.AppendLiteral(".page_size = ");
 521       query.AppendInt(mSetPageSize);
 522       nsCOMPtr<mozIStorageStatement> stmt;
 523       rv = mConnection->ExecuteSimpleSQL(query);
 524       NS_ENSURE_SUCCESS(rv, rv);
 525     }
 526
 527     // Check auto_vacuum.
 528     {
 529       nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
 530       query.Append(aSchemaName);
 531       query.AppendLiteral(".auto_vacuum");
 532       nsCOMPtr<mozIStorageStatement> stmt;
 533       rv = mConnection->CreateStatement(query, getter_AddRefs(stmt));
 534       NS_ENSURE_SUCCESS(rv, rv);
 535       bool hasResult = false;
 536       bool changeAutoVacuum = false;
 537       if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
 538         bool isIncrementalVacuum = stmt->AsInt32(0) == 2;
 539         changeAutoVacuum = isIncrementalVacuum != mUseIncremental;
 540         if (isIncrementalVacuum && !changeAutoVacuum) {
 541           needsFullVacuum = false;
 542         }
 543       }
 544       // Changing auto_vacuum is only supported on the main schema.
 545       if (aSchemaName.EqualsLiteral("main") && changeAutoVacuum) {
 546         nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
 547         query.Append(aSchemaName);
 548         query.AppendLiteral(".auto_vacuum = ");
 549         query.AppendInt(mUseIncremental ? 2 : 0);
 550         rv = mConnection->ExecuteSimpleSQL(query);
 551         NS_ENSURE_SUCCESS(rv, rv);
 552       }
 553     }
 554
 555     if (needsFullVacuum) {
 556       nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "VACUUM ");
 557       query.Append(aSchemaName);
 558       rv = mConnection->ExecuteSimpleSQL(query);
 559       // TODO (Bug 1818039): Report failed vacuum telemetry.
 560       NS_ENSURE_SUCCESS(rv, rv);
 561     } else {
 562       nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
 563       query.Append(aSchemaName);
 564       query.AppendLiteral(".incremental_vacuum(");
 565       query.AppendInt(removablePages);
 566       query.AppendLiteral(")");
 567       rv = mConnection->ExecuteSimpleSQL(query);
 568       NS_ENSURE_SUCCESS(rv, rv);
 569     }
 570
 571     return NS_OK;
 572   }
 573
 574   ~AsyncVacuumEvent() override {
 575     NS_ReleaseOnMainThread("AsyncVacuum::mConnection", mConnection.forget());
 576     NS_ReleaseOnMainThread("AsyncVacuum::mCallback", mCallback.forget());
 577   }
 578
 579  private:
 580   RefPtr<Connection> mConnection;
 581   nsCOMPtr<mozIStorageCompletionCallback> mCallback;
 582   bool mUseIncremental;
 583   int32_t mSetPageSize;
 584   Atomic<nsresult> mStatus;
 585 };
 586
 587 /**
 588  * A runnable to perform an SQLite database backup when there may be one or more
 589  * open connections on that database.
 590  */
 591 class AsyncBackupDatabaseFile final : public Runnable, public nsITimerCallback {
 592  public:
 593   NS_DECL_ISUPPORTS_INHERITED
 594
 595   /**
 596    * @param aConnection The connection to the database being backed up.
 597    * @param aNativeConnection The native connection to the database being backed
 598    *                          up.
 599    * @param aDestinationFile The destination file for the created backup.
 600    * @param aCallback A callback to trigger once the backup process has
 601    *                  completed. The callback will be supplied with an nsresult
 602    *                  indicating whether or not the backup was successfully
 603    *                  created. This callback will be called on the
 604    *                  mConnection->eventTargetOpenedOn thread.
 605    * @throws
 606    */
 607   AsyncBackupDatabaseFile(Connection* aConnection, sqlite3* aNativeConnection,
 608                           nsIFile* aDestinationFile,
 609                           mozIStorageCompletionCallback* aCallback)
 610       : Runnable("storage::AsyncBackupDatabaseFile"),
 611         mConnection(aConnection),
 612         mNativeConnection(aNativeConnection),
 613         mDestinationFile(aDestinationFile),
 614         mCallback(aCallback),
 615         mBackupFile(nullptr),
 616         mBackupHandle(nullptr) {
 617     MOZ_ASSERT(NS_IsMainThread());
 618   }
 619
 620   NS_IMETHOD Run() override {
 621     MOZ_ASSERT(!NS_IsMainThread());
 622
 623     nsAutoString path;
 624     nsresult rv = mDestinationFile->GetPath(path);
 625     if (NS_FAILED(rv)) {
 626       return Dispatch(rv, nullptr);
 627     }
 628     // Put a .tmp on the end of the destination while the backup is underway.
 629     // This extension will be stripped off after the backup successfully
 630     // completes.
 631     path.AppendLiteral(".tmp");
 632
 633     int srv = ::sqlite3_open(NS_ConvertUTF16toUTF8(path).get(), &mBackupFile);
 634     if (srv != SQLITE_OK) {
 635       return Dispatch(NS_ERROR_FAILURE, nullptr);
 636     }
 637
 638     static const char* mainDBName = "main";
 639
 640     mBackupHandle = ::sqlite3_backup_init(mBackupFile, mainDBName,
 641                                           mNativeConnection, mainDBName);
 642     if (!mBackupHandle) {
 643       MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
 644       return Dispatch(NS_ERROR_FAILURE, nullptr);
 645     }
 646
 647     return DoStep();
 648   }
 649
 650   NS_IMETHOD
 651   Notify(nsITimer* aTimer) override { return DoStep(); }
 652
 653  private:
 654   nsresult DoStep() {
 655 #define DISPATCH_AND_RETURN_IF_FAILED(rv) \
 656   if (NS_FAILED(rv)) {                    \
 657     return Dispatch(rv, nullptr);         \
 658   }
 659
 660     // This guard is used to close the backup database in the event of
 661     // some failure throughout this process. We release the exit guard
 662     // only if we complete the backup successfully, or defer to another
 663     // later call to DoStep.
 664     auto guard = MakeScopeExit([&]() {
 665       MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
 666       mBackupFile = nullptr;
 667     });
 668
 669     MOZ_ASSERT(!NS_IsMainThread());
 670     nsAutoString originalPath;
 671     nsresult rv = mDestinationFile->GetPath(originalPath);
 672     DISPATCH_AND_RETURN_IF_FAILED(rv);
 673
 674     nsAutoString tempPath = originalPath;
 675     tempPath.AppendLiteral(".tmp");
 676
 677     nsCOMPtr<nsIFile> file =
 678         do_CreateInstance("@mozilla.org/file/local;1", &rv);
 679     DISPATCH_AND_RETURN_IF_FAILED(rv);
 680
 681     rv = file->InitWithPath(tempPath);
 682     DISPATCH_AND_RETURN_IF_FAILED(rv);
 683
 684     // The number of milliseconds to wait between each batch of copies.
 685     static constexpr uint32_t STEP_DELAY_MS = 250;
 686     // The number of pages to copy per step
 687     static constexpr int COPY_PAGES = 5;
 688
 689     int srv = ::sqlite3_backup_step(mBackupHandle, COPY_PAGES);
 690     if (srv == SQLITE_OK || srv == SQLITE_BUSY || srv == SQLITE_LOCKED) {
 691       // We're continuing the backup later. Release the guard to avoid closing
 692       // the database.
 693       guard.release();
 694       // Queue up the next step
 695       return NS_NewTimerWithCallback(getter_AddRefs(mTimer), this,
 696                                      STEP_DELAY_MS, nsITimer::TYPE_ONE_SHOT,
 697                                      GetCurrentSerialEventTarget());
 698     }
 699 #ifdef DEBUG
 700     if (srv != SQLITE_DONE) {
 701       nsCString warnMsg;
 702       warnMsg.AppendLiteral(
 703           "The SQLite database copy could not be completed due to an error: ");
 704       warnMsg.Append(::sqlite3_errmsg(mBackupFile));
 705       NS_WARNING(warnMsg.get());
 706     }
 707 #endif
 708
 709     (void)::sqlite3_backup_finish(mBackupHandle);
 710     MOZ_ALWAYS_TRUE(::sqlite3_close(mBackupFile) == SQLITE_OK);
 711     mBackupFile = nullptr;
 712
 713     // The database is already closed, so we can release this guard now.
 714     guard.release();
 715
 716     if (srv != SQLITE_DONE) {
 717       NS_WARNING("Failed to create database copy.");
 718
 719       // The partially created database file is not useful. Let's remove it.
 720       rv = file->Remove(false);
 721       if (NS_FAILED(rv)) {
 722         NS_WARNING(
 723             "Removing a partially backed up SQLite database file failed.");
 724       }
 725
 726       return Dispatch(convertResultCode(srv), nullptr);
 727     }
 728
 729     // Now that we've successfully created the copy, we'll strip off the .tmp
 730     // extension.
 731
 732     nsAutoString leafName;
 733     rv = mDestinationFile->GetLeafName(leafName);
 734     DISPATCH_AND_RETURN_IF_FAILED(rv);
 735
 736     rv = file->RenameTo(nullptr, leafName);
 737     DISPATCH_AND_RETURN_IF_FAILED(rv);
 738
 739 #undef DISPATCH_AND_RETURN_IF_FAILED
 740     return Dispatch(NS_OK, nullptr);
 741   }
 742
 743   nsresult Dispatch(nsresult aResult, nsISupports* aValue) {
 744     RefPtr<CallbackComplete> event =
 745         new CallbackComplete(aResult, aValue, mCallback.forget());
 746     return mConnection->eventTargetOpenedOn->Dispatch(event,
 747                                                       NS_DISPATCH_NORMAL);
 748   }
 749
 750   ~AsyncBackupDatabaseFile() override {
 751     nsresult rv;
 752     nsCOMPtr<nsIThread> thread =
 753         do_QueryInterface(mConnection->eventTargetOpenedOn, &rv);
 754     MOZ_ASSERT(NS_SUCCEEDED(rv));
 755
 756     // Handle ambiguous nsISupports inheritance.
 757     NS_ProxyRelease("AsyncBackupDatabaseFile::mConnection", thread,
 758                     mConnection.forget());
 759     NS_ProxyRelease("AsyncBackupDatabaseFile::mDestinationFile", thread,
 760                     mDestinationFile.forget());
 761
 762     // Generally, the callback will be released by CallbackComplete.
 763     // However, if for some reason Run() is not executed, we still
 764     // need to ensure that it is released here.
 765     NS_ProxyRelease("AsyncInitializeClone::mCallback", thread,
 766                     mCallback.forget());
 767   }
 768
 769   RefPtr<Connection> mConnection;
 770   sqlite3* mNativeConnection;
 771   nsCOMPtr<nsITimer> mTimer;
 772   nsCOMPtr<nsIFile> mDestinationFile;
 773   nsCOMPtr<mozIStorageCompletionCallback> mCallback;
 774   sqlite3* mBackupFile;
 775   sqlite3_backup* mBackupHandle;
 776 };
 777
 778 NS_IMPL_ISUPPORTS_INHERITED(AsyncBackupDatabaseFile, Runnable, nsITimerCallback)
 779
 780 }  // namespace
 781
 782 ////////////////////////////////////////////////////////////////////////////////
 783 //// Connection
 784
 785 Connection::Connection(Service* aService, int aFlags,
 786                        ConnectionOperation aSupportedOperations,
 787                        const nsCString& aTelemetryFilename, bool aInterruptible,
 788                        bool aIgnoreLockingMode)
 789     : sharedAsyncExecutionMutex("Connection::sharedAsyncExecutionMutex"),
 790       sharedDBMutex("Connection::sharedDBMutex"),
 791       eventTargetOpenedOn(WrapNotNull(GetCurrentSerialEventTarget())),
 792       mIsStatementOnHelperThreadInterruptible(false),
 793       mDBConn(nullptr),
 794       mDefaultTransactionType(mozIStorageConnection::TRANSACTION_DEFERRED),
 795       mDestroying(false),
 796       mProgressHandler(nullptr),
 797       mStorageService(aService),
 798       mFlags(aFlags),
 799       mTransactionNestingLevel(0),
 800       mSupportedOperations(aSupportedOperations),
 801       mInterruptible(aSupportedOperations == Connection::ASYNCHRONOUS ||
 802                      aInterruptible),
 803       mIgnoreLockingMode(aIgnoreLockingMode),
 804       mAsyncExecutionThreadShuttingDown(false),
 805       mConnectionClosed(false),
 806       mGrowthChunkSize(0) {
 807   MOZ_ASSERT(!mIgnoreLockingMode || mFlags & SQLITE_OPEN_READONLY,
 808              "Can't ignore locking for a non-readonly connection!");
 809   mStorageService->registerConnection(this);
 810   MOZ_ASSERT(!aTelemetryFilename.IsEmpty(),
 811              "A telemetry filename should have been passed-in.");
 812   mTelemetryFilename.Assign(aTelemetryFilename);
 813 }
 814
 815 Connection::~Connection() {
 816   // Failsafe Close() occurs in our custom Release method because of
 817   // complications related to Close() potentially invoking AsyncClose() which
 818   // will increment our refcount.
 819   MOZ_ASSERT(!mAsyncExecutionThread,
 820              "The async thread has not been shutdown properly!");
 821 }
 822
 823 NS_IMPL_ADDREF(Connection)
 824
 825 NS_INTERFACE_MAP_BEGIN(Connection)
 826   NS_INTERFACE_MAP_ENTRY(mozIStorageAsyncConnection)
 827   NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
 828   NS_INTERFACE_MAP_ENTRY(mozIStorageConnection)
 829   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageConnection)
 830 NS_INTERFACE_MAP_END
 831
 832 // This is identical to what NS_IMPL_RELEASE provides, but with the
 833 // extra |1 == count| case.
 834 NS_IMETHODIMP_(MozExternalRefCountType) Connection::Release(void) {
 835   MOZ_ASSERT(0 != mRefCnt, "dup release");
 836   nsrefcnt count = --mRefCnt;
 837   NS_LOG_RELEASE(this, count, "Connection");
 838   if (1 == count) {
 839     // If the refcount went to 1, the single reference must be from
 840     // gService->mConnections (in class |Service|).  And the code calling
 841     // Release is either:
 842     // - The "user" code that had created the connection, releasing on any
 843     //   thread.
 844     // - One of Service's getConnections() callers had acquired a strong
 845     //   reference to the Connection that out-lived the last "user" reference,
 846     //   and now that just got dropped.  Note that this reference could be
 847     //   getting dropped on the main thread or Connection->eventTargetOpenedOn
 848     //   (because of the NewRunnableMethod used by minimizeMemory).
 849     //
 850     // Either way, we should now perform our failsafe Close() and unregister.
 851     // However, we only want to do this once, and the reality is that our
 852     // refcount could go back up above 1 and down again at any time if we are
 853     // off the main thread and getConnections() gets called on the main thread,
 854     // so we use an atomic here to do this exactly once.
 855     if (mDestroying.compareExchange(false, true)) {
 856       // Close the connection, dispatching to the opening event target if we're
 857       // not on that event target already and that event target is still
 858       // accepting runnables. We do this because it's possible we're on the main
 859       // thread because of getConnections(), and we REALLY don't want to
 860       // transfer I/O to the main thread if we can avoid it.
 861       if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
 862         // This could cause SpinningSynchronousClose() to be invoked and AddRef
 863         // triggered for AsyncCloseConnection's strong ref if the conn was ever
 864         // use for async purposes.  (Main-thread only, though.)
 865         Unused << synchronousClose();
 866       } else {
 867         nsCOMPtr<nsIRunnable> event =
 868             NewRunnableMethod("storage::Connection::synchronousClose", this,
 869                               &Connection::synchronousClose);
 870         if (NS_FAILED(eventTargetOpenedOn->Dispatch(event.forget(),
 871                                                     NS_DISPATCH_NORMAL))) {
 872           // The event target was dead and so we've just leaked our runnable.
 873           // This should not happen because our non-main-thread consumers should
 874           // be explicitly closing their connections, not relying on us to close
 875           // them for them.  (It's okay to let a statement go out of scope for
 876           // automatic cleanup, but not a Connection.)
 877           MOZ_ASSERT(false,
 878                      "Leaked Connection::synchronousClose(), ownership fail.");
 879           Unused << synchronousClose();
 880         }
 881       }
 882
 883       // This will drop its strong reference right here, right now.
 884       mStorageService->unregisterConnection(this);
 885     }
 886   } else if (0 == count) {
 887     mRefCnt = 1; /* stabilize */
 888 #if 0            /* enable this to find non-threadsafe destructors: */
 889     NS_ASSERT_OWNINGTHREAD(Connection);
 890 #endif
 891     delete (this);
 892     return 0;
 893   }
 894   return count;
 895 }
 896
 897 int32_t Connection::getSqliteRuntimeStatus(int32_t aStatusOption,
 898                                            int32_t* aMaxValue) {
 899   MOZ_ASSERT(connectionReady(), "A connection must exist at this point");
 900   int curr = 0, max = 0;
 901   DebugOnly<int> rc =
 902       ::sqlite3_db_status(mDBConn, aStatusOption, &curr, &max, 0);
 903   MOZ_ASSERT(NS_SUCCEEDED(convertResultCode(rc)));
 904   if (aMaxValue) *aMaxValue = max;
 905   return curr;
 906 }
 907
 908 nsIEventTarget* Connection::getAsyncExecutionTarget() {
 909   NS_ENSURE_TRUE(IsOnCurrentSerialEventTarget(eventTargetOpenedOn), nullptr);
 910
 911   // Don't return the asynchronous event target if we are shutting down.
 912   if (mAsyncExecutionThreadShuttingDown) {
 913     return nullptr;
 914   }
 915
 916   // Create the async event target if there's none yet.
 917   if (!mAsyncExecutionThread) {
 918     // Names start with "sqldb:" followed by a recognizable name, like the
 919     // database file name, or a specially crafted name like "memory".
 920     // This name will be surfaced on https://crash-stats.mozilla.org, so any
 921     // sensitive part of the file name (e.g. an URL origin) should be replaced
 922     // by passing an explicit telemetryName to openDatabaseWithFileURL.
 923     nsAutoCString name("sqldb:"_ns);
 924     name.Append(mTelemetryFilename);
 925     static nsThreadPoolNaming naming;
 926     nsresult rv = NS_NewNamedThread(naming.GetNextThreadName(name),
 927                                     getter_AddRefs(mAsyncExecutionThread));
 928     if (NS_FAILED(rv)) {
 929       NS_WARNING("Failed to create async thread.");
 930       return nullptr;
 931     }
 932     mAsyncExecutionThread->SetNameForWakeupTelemetry("mozStorage (all)"_ns);
 933   }
 934
 935   return mAsyncExecutionThread;
 936 }
 937
 938 void Connection::RecordOpenStatus(nsresult rv) {
 939   nsCString histogramKey = mTelemetryFilename;
 940
 941   if (histogramKey.IsEmpty()) {
 942     histogramKey.AssignLiteral("unknown");
 943   }
 944
 945   if (NS_SUCCEEDED(rv)) {
 946     AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_OPEN::success);
 947     return;
 948   }
 949
 950   switch (rv) {
 951     case NS_ERROR_FILE_CORRUPTED:
 952       AccumulateCategoricalKeyed(histogramKey,
 953                                  LABELS_SQLITE_STORE_OPEN::corrupt);
 954       break;
 955     case NS_ERROR_STORAGE_IOERR:
 956       AccumulateCategoricalKeyed(histogramKey,
 957                                  LABELS_SQLITE_STORE_OPEN::diskio);
 958       break;
 959     case NS_ERROR_FILE_ACCESS_DENIED:
 960     case NS_ERROR_FILE_IS_LOCKED:
 961     case NS_ERROR_FILE_READ_ONLY:
 962       AccumulateCategoricalKeyed(histogramKey,
 963                                  LABELS_SQLITE_STORE_OPEN::access);
 964       break;
 965     case NS_ERROR_FILE_NO_DEVICE_SPACE:
 966       AccumulateCategoricalKeyed(histogramKey,
 967                                  LABELS_SQLITE_STORE_OPEN::diskspace);
 968       break;
 969     default:
 970       AccumulateCategoricalKeyed(histogramKey,
 971                                  LABELS_SQLITE_STORE_OPEN::failure);
 972   }
 973 }
 974
 975 void Connection::RecordQueryStatus(int srv) {
 976   nsCString histogramKey = mTelemetryFilename;
 977
 978   if (histogramKey.IsEmpty()) {
 979     histogramKey.AssignLiteral("unknown");
 980   }
 981
 982   switch (srv) {
 983     case SQLITE_OK:
 984     case SQLITE_ROW:
 985     case SQLITE_DONE:
 986
 987     // Note that these are returned when we intentionally cancel a statement so
 988     // they aren't indicating a failure.
 989     case SQLITE_ABORT:
 990     case SQLITE_INTERRUPT:
 991       AccumulateCategoricalKeyed(histogramKey,
 992                                  LABELS_SQLITE_STORE_QUERY::success);
 993       break;
 994     case SQLITE_CORRUPT:
 995     case SQLITE_NOTADB:
 996       AccumulateCategoricalKeyed(histogramKey,
 997                                  LABELS_SQLITE_STORE_QUERY::corrupt);
 998       break;
 999     case SQLITE_PERM:
1000     case SQLITE_CANTOPEN:
1001     case SQLITE_LOCKED:
1002     case SQLITE_READONLY:
1003       AccumulateCategoricalKeyed(histogramKey,
1004                                  LABELS_SQLITE_STORE_QUERY::access);
1005       break;
1006     case SQLITE_IOERR:
1007     case SQLITE_NOLFS:
1008       AccumulateCategoricalKeyed(histogramKey,
1009                                  LABELS_SQLITE_STORE_QUERY::diskio);
1010       break;
1011     case SQLITE_FULL:
1012     case SQLITE_TOOBIG:
1013       AccumulateCategoricalKeyed(histogramKey,
1014                                  LABELS_SQLITE_STORE_QUERY::diskspace);
1015       break;
1016     case SQLITE_CONSTRAINT:
1017     case SQLITE_RANGE:
1018     case SQLITE_MISMATCH:
1019     case SQLITE_MISUSE:
1020       AccumulateCategoricalKeyed(histogramKey,
1021                                  LABELS_SQLITE_STORE_QUERY::misuse);
1022       break;
1023     case SQLITE_BUSY:
1024       AccumulateCategoricalKeyed(histogramKey, LABELS_SQLITE_STORE_QUERY::busy);
1025       break;
1026     default:
1027       AccumulateCategoricalKeyed(histogramKey,
1028                                  LABELS_SQLITE_STORE_QUERY::failure);
1029   }
1030 }
1031
1032 nsresult Connection::initialize(const nsACString& aStorageKey,
1033                                 const nsACString& aName) {
1034   MOZ_ASSERT(aStorageKey.Equals(kMozStorageMemoryStorageKey));
1035   NS_ASSERTION(!connectionReady(),
1036                "Initialize called on already opened database!");
1037   MOZ_ASSERT(!mIgnoreLockingMode, "Can't ignore locking on an in-memory db.");
1038   AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1039
1040   mStorageKey = aStorageKey;
1041   mName = aName;
1042
1043   // in memory database requested, sqlite uses a magic file name
1044
1045   const nsAutoCString path =
1046       mName.IsEmpty() ? nsAutoCString(":memory:"_ns)
1047                       : "file:"_ns + mName + "?mode=memory&cache=shared"_ns;
1048
1049   int srv = ::sqlite3_open_v2(path.get(), &mDBConn, mFlags,
1050                               basevfs::GetVFSName(true));
1051   if (srv != SQLITE_OK) {
1052     mDBConn = nullptr;
1053     nsresult rv = convertResultCode(srv);
1054     RecordOpenStatus(rv);
1055     return rv;
1056   }
1057
1058 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
1059   srv =
1060       ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
1061   MOZ_ASSERT(srv == SQLITE_OK,
1062              "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
1063 #endif
1064
1065   // Do not set mDatabaseFile or mFileURL here since this is a "memory"
1066   // database.
1067
1068   nsresult rv = initializeInternal();
1069   RecordOpenStatus(rv);
1070   NS_ENSURE_SUCCESS(rv, rv);
1071
1072   return NS_OK;
1073 }
1074
1075 nsresult Connection::initialize(nsIFile* aDatabaseFile) {
1076   NS_ASSERTION(aDatabaseFile, "Passed null file!");
1077   NS_ASSERTION(!connectionReady(),
1078                "Initialize called on already opened database!");
1079   AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1080
1081   // Do not set mFileURL here since this is database does not have an associated
1082   // URL.
1083   mDatabaseFile = aDatabaseFile;
1084
1085   nsAutoString path;
1086   nsresult rv = aDatabaseFile->GetPath(path);
1087   NS_ENSURE_SUCCESS(rv, rv);
1088
1089   bool exclusive = StaticPrefs::storage_sqlite_exclusiveLock_enabled();
1090   int srv;
1091   if (mIgnoreLockingMode) {
1092     exclusive = false;
1093     srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1094                             "readonly-immutable-nolock");
1095   } else {
1096     srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1097                             basevfs::GetVFSName(exclusive));
1098     if (exclusive && (srv == SQLITE_LOCKED || srv == SQLITE_BUSY)) {
1099       // Retry without trying to get an exclusive lock.
1100       exclusive = false;
1101       srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn,
1102                               mFlags, basevfs::GetVFSName(false));
1103     }
1104   }
1105   if (srv != SQLITE_OK) {
1106     mDBConn = nullptr;
1107     rv = convertResultCode(srv);
1108     RecordOpenStatus(rv);
1109     return rv;
1110   }
1111
1112   rv = initializeInternal();
1113   if (exclusive &&
1114       (rv == NS_ERROR_STORAGE_BUSY || rv == NS_ERROR_FILE_IS_LOCKED)) {
1115     // Usually SQLite will fail to acquire an exclusive lock on opening, but in
1116     // some cases it may successfully open the database and then lock on the
1117     // first query execution. When initializeInternal fails it closes the
1118     // connection, so we can try to restart it in non-exclusive mode.
1119     srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn, mFlags,
1120                             basevfs::GetVFSName(false));
1121     if (srv == SQLITE_OK) {
1122       rv = initializeInternal();
1123     }
1124   }
1125
1126   RecordOpenStatus(rv);
1127   NS_ENSURE_SUCCESS(rv, rv);
1128
1129   return NS_OK;
1130 }
1131
1132 nsresult Connection::initialize(nsIFileURL* aFileURL) {
1133   NS_ASSERTION(aFileURL, "Passed null file URL!");
1134   NS_ASSERTION(!connectionReady(),
1135                "Initialize called on already opened database!");
1136   AUTO_PROFILER_LABEL("Connection::initialize", OTHER);
1137
1138   nsCOMPtr<nsIFile> databaseFile;
1139   nsresult rv = aFileURL->GetFile(getter_AddRefs(databaseFile));
1140   NS_ENSURE_SUCCESS(rv, rv);
1141
1142   // Set both mDatabaseFile and mFileURL here.
1143   mFileURL = aFileURL;
1144   mDatabaseFile = databaseFile;
1145
1146   nsAutoCString spec;
1147   rv = aFileURL->GetSpec(spec);
1148   NS_ENSURE_SUCCESS(rv, rv);
1149
1150   // If there is a key specified, we need to use the obfuscating VFS.
1151   nsAutoCString query;
1152   rv = aFileURL->GetQuery(query);
1153   NS_ENSURE_SUCCESS(rv, rv);
1154
1155   bool hasKey = false;
1156   bool hasDirectoryLockId = false;
1157
1158   MOZ_ALWAYS_TRUE(
1159       URLParams::Parse(query, true,
1160                        [&hasKey, &hasDirectoryLockId](const nsAString& aName,
1161                                                       const nsAString& aValue) {
1162                          if (aName.EqualsLiteral("key")) {
1163                            hasKey = true;
1164                            return true;
1165                          }
1166                          if (aName.EqualsLiteral("directoryLockId")) {
1167                            hasDirectoryLockId = true;
1168                            return true;
1169                          }
1170                          return true;
1171                        }));
1172
1173   bool exclusive = StaticPrefs::storage_sqlite_exclusiveLock_enabled();
1174
1175   const char* const vfs = hasKey               ? obfsvfs::GetVFSName()
1176                           : hasDirectoryLockId ? quotavfs::GetVFSName()
1177                                                : basevfs::GetVFSName(exclusive);
1178
1179   int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, vfs);
1180   if (srv != SQLITE_OK) {
1181     mDBConn = nullptr;
1182     rv = convertResultCode(srv);
1183     RecordOpenStatus(rv);
1184     return rv;
1185   }
1186
1187   rv = initializeInternal();
1188   RecordOpenStatus(rv);
1189   NS_ENSURE_SUCCESS(rv, rv);
1190
1191   return NS_OK;
1192 }
1193
1194 nsresult Connection::initializeInternal() {
1195   MOZ_ASSERT(mDBConn);
1196   auto guard = MakeScopeExit([&]() { initializeFailed(); });
1197
1198   mConnectionClosed = false;
1199
1200 #ifdef MOZ_SQLITE_FTS3_TOKENIZER
1201   DebugOnly<int> srv2 =
1202       ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, 1, 0);
1203   MOZ_ASSERT(srv2 == SQLITE_OK,
1204              "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER should be enabled");
1205 #endif
1206
1207   // Properly wrap the database handle's mutex.
1208   sharedDBMutex.initWithMutex(sqlite3_db_mutex(mDBConn));
1209
1210   // SQLite tracing can slow down queries (especially long queries)
1211   // significantly. Don't trace unless the user is actively monitoring SQLite.
1212   if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {
1213     ::sqlite3_trace_v2(mDBConn, SQLITE_TRACE_STMT | SQLITE_TRACE_PROFILE,
1214                        tracefunc, this);
1215
1216     MOZ_LOG(
1217         gStorageLog, LogLevel::Debug,
1218         ("Opening connection to '%s' (%p)", mTelemetryFilename.get(), this));
1219   }
1220
1221   int64_t pageSize = Service::kDefaultPageSize;
1222
1223   // Set page_size to the preferred default value.  This is effective only if
1224   // the database has just been created, otherwise, if the database does not
1225   // use WAL journal mode, a VACUUM operation will updated its page_size.
1226   nsAutoCString pageSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR
1227                               "PRAGMA page_size = ");
1228   pageSizeQuery.AppendInt(pageSize);
1229   int srv = executeSql(mDBConn, pageSizeQuery.get());
1230   if (srv != SQLITE_OK) {
1231     return convertResultCode(srv);
1232   }
1233
1234   // Setting the cache_size forces the database open, verifying if it is valid
1235   // or corrupt.  So this is executed regardless it being actually needed.
1236   // The cache_size is calculated from the actual page_size, to save memory.
1237   nsAutoCString cacheSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR
1238                                "PRAGMA cache_size = ");
1239   cacheSizeQuery.AppendInt(-MAX_CACHE_SIZE_KIBIBYTES);
1240   srv = executeSql(mDBConn, cacheSizeQuery.get());
1241   if (srv != SQLITE_OK) {
1242     return convertResultCode(srv);
1243   }
1244
1245   // Register our built-in SQL functions.
1246   srv = registerFunctions(mDBConn);
1247   if (srv != SQLITE_OK) {
1248     return convertResultCode(srv);
1249   }
1250
1251   // Register our built-in SQL collating sequences.
1252   srv = registerCollations(mDBConn, mStorageService);
1253   if (srv != SQLITE_OK) {
1254     return convertResultCode(srv);
1255   }
1256
1257   // Set the default synchronous value. Each consumer can switch this
1258   // accordingly to their needs.
1259 #if defined(ANDROID)
1260   // Android prefers synchronous = OFF for performance reasons.
1261   Unused << ExecuteSimpleSQL("PRAGMA synchronous = OFF;"_ns);
1262 #else
1263   // Normal is the suggested value for WAL journals.
1264   Unused << ExecuteSimpleSQL("PRAGMA synchronous = NORMAL;"_ns);
1265 #endif
1266
1267   // Initialization succeeded, we can stop guarding for failures.
1268   guard.release();
1269   return NS_OK;
1270 }
1271
1272 nsresult Connection::initializeOnAsyncThread(nsIFile* aStorageFile) {
1273   MOZ_ASSERT(!IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1274   nsresult rv = aStorageFile
1275                     ? initialize(aStorageFile)
1276                     : initialize(kMozStorageMemoryStorageKey, VoidCString());
1277   if (NS_FAILED(rv)) {
1278     // Shutdown the async thread, since initialization failed.
1279     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1280     mAsyncExecutionThreadShuttingDown = true;
1281     nsCOMPtr<nsIRunnable> event =
1282         NewRunnableMethod("Connection::shutdownAsyncThread", this,
1283                           &Connection::shutdownAsyncThread);
1284     Unused << NS_DispatchToMainThread(event);
1285   }
1286   return rv;
1287 }
1288
1289 void Connection::initializeFailed() {
1290   {
1291     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1292     mConnectionClosed = true;
1293   }
1294   MOZ_ALWAYS_TRUE(::sqlite3_close(mDBConn) == SQLITE_OK);
1295   mDBConn = nullptr;
1296   sharedDBMutex.destroy();
1297 }
1298
1299 nsresult Connection::databaseElementExists(
1300     enum DatabaseElementType aElementType, const nsACString& aElementName,
1301     bool* _exists) {
1302   if (!connectionReady()) {
1303     return NS_ERROR_NOT_AVAILABLE;
1304   }
1305   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1306   if (NS_FAILED(rv)) {
1307     return rv;
1308   }
1309
1310   // When constructing the query, make sure to SELECT the correct db's
1311   // sqlite_master if the user is prefixing the element with a specific db. ex:
1312   // sample.test
1313   nsCString query("SELECT name FROM (SELECT * FROM ");
1314   nsDependentCSubstring element;
1315   int32_t ind = aElementName.FindChar('.');
1316   if (ind == kNotFound) {
1317     element.Assign(aElementName);
1318   } else {
1319     nsDependentCSubstring db(Substring(aElementName, 0, ind + 1));
1320     element.Assign(Substring(aElementName, ind + 1, aElementName.Length()));
1321     query.Append(db);
1322   }
1323   query.AppendLiteral(
1324       "sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = "
1325       "'");
1326
1327   switch (aElementType) {
1328     case INDEX:
1329       query.AppendLiteral("index");
1330       break;
1331     case TABLE:
1332       query.AppendLiteral("table");
1333       break;
1334   }
1335   query.AppendLiteral("' AND name ='");
1336   query.Append(element);
1337   query.Append('\'');
1338
1339   sqlite3_stmt* stmt;
1340   int srv = prepareStatement(mDBConn, query, &stmt);
1341   if (srv != SQLITE_OK) {
1342     RecordQueryStatus(srv);
1343     return convertResultCode(srv);
1344   }
1345
1346   srv = stepStatement(mDBConn, stmt);
1347   // we just care about the return value from step
1348   (void)::sqlite3_finalize(stmt);
1349
1350   RecordQueryStatus(srv);
1351
1352   if (srv == SQLITE_ROW) {
1353     *_exists = true;
1354     return NS_OK;
1355   }
1356   if (srv == SQLITE_DONE) {
1357     *_exists = false;
1358     return NS_OK;
1359   }
1360
1361   return convertResultCode(srv);
1362 }
1363
1364 bool Connection::findFunctionByInstance(mozIStorageFunction* aInstance) {
1365   sharedDBMutex.assertCurrentThreadOwns();
1366
1367   for (const auto& data : mFunctions.Values()) {
1368     if (data.function == aInstance) {
1369       return true;
1370     }
1371   }
1372   return false;
1373 }
1374
1375 /* static */
1376 int Connection::sProgressHelper(void* aArg) {
1377   Connection* _this = static_cast<Connection*>(aArg);
1378   return _this->progressHandler();
1379 }
1380
1381 int Connection::progressHandler() {
1382   sharedDBMutex.assertCurrentThreadOwns();
1383   if (mProgressHandler) {
1384     bool result;
1385     nsresult rv = mProgressHandler->OnProgress(this, &result);
1386     if (NS_FAILED(rv)) return 0;  // Don't break request
1387     return result ? 1 : 0;
1388   }
1389   return 0;
1390 }
1391
1392 nsresult Connection::setClosedState() {
1393   // Flag that we are shutting down the async thread, so that
1394   // getAsyncExecutionTarget knows not to expose/create the async thread.
1395   MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1396   NS_ENSURE_FALSE(mAsyncExecutionThreadShuttingDown, NS_ERROR_UNEXPECTED);
1397
1398   mAsyncExecutionThreadShuttingDown = true;
1399
1400   // Set the property to null before closing the connection, otherwise the
1401   // other functions in the module may try to use the connection after it is
1402   // closed.
1403   mDBConn = nullptr;
1404
1405   return NS_OK;
1406 }
1407
1408 bool Connection::operationSupported(ConnectionOperation aOperationType) {
1409   if (aOperationType == ASYNCHRONOUS) {
1410     // Async operations are supported for all connections, on any thread.
1411     return true;
1412   }
1413   // Sync operations are supported for sync connections (on any thread), and
1414   // async connections on a background thread.
1415   MOZ_ASSERT(aOperationType == SYNCHRONOUS);
1416   return mSupportedOperations == SYNCHRONOUS || !NS_IsMainThread();
1417 }
1418
1419 nsresult Connection::ensureOperationSupported(
1420     ConnectionOperation aOperationType) {
1421   if (NS_WARN_IF(!operationSupported(aOperationType))) {
1422 #ifdef DEBUG
1423     if (NS_IsMainThread()) {
1424       nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1425       Unused << xpc->DebugDumpJSStack(false, false, false);
1426     }
1427 #endif
1428     MOZ_ASSERT(false,
1429                "Don't use async connections synchronously on the main thread");
1430     return NS_ERROR_NOT_AVAILABLE;
1431   }
1432   return NS_OK;
1433 }
1434
1435 bool Connection::isConnectionReadyOnThisThread() {
1436   MOZ_ASSERT_IF(connectionReady(), !mConnectionClosed);
1437   if (mAsyncExecutionThread && mAsyncExecutionThread->IsOnCurrentThread()) {
1438     return true;
1439   }
1440   return connectionReady();
1441 }
1442
1443 bool Connection::isClosing() {
1444   MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1445   return mAsyncExecutionThreadShuttingDown && !mConnectionClosed;
1446 }
1447
1448 bool Connection::isClosed() {
1449   MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1450   return mConnectionClosed;
1451 }
1452
1453 bool Connection::isClosed(MutexAutoLock& lock) { return mConnectionClosed; }
1454
1455 bool Connection::isAsyncExecutionThreadAvailable() {
1456   MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1457   return mAsyncExecutionThread && !mAsyncExecutionThreadShuttingDown;
1458 }
1459
1460 void Connection::shutdownAsyncThread() {
1461   MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1462   MOZ_ASSERT(mAsyncExecutionThread);
1463   MOZ_ASSERT(mAsyncExecutionThreadShuttingDown);
1464
1465   MOZ_ALWAYS_SUCCEEDS(mAsyncExecutionThread->Shutdown());
1466   mAsyncExecutionThread = nullptr;
1467 }
1468
1469 nsresult Connection::internalClose(sqlite3* aNativeConnection) {
1470 #ifdef DEBUG
1471   {  // Make sure we have marked our async thread as shutting down.
1472     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1473     MOZ_ASSERT(mAsyncExecutionThreadShuttingDown,
1474                "Did not call setClosedState!");
1475     MOZ_ASSERT(!isClosed(lockedScope), "Unexpected closed state");
1476   }
1477 #endif  // DEBUG
1478
1479   if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {
1480     nsAutoCString leafName(":memory");
1481     if (mDatabaseFile) (void)mDatabaseFile->GetNativeLeafName(leafName);
1482     MOZ_LOG(gStorageLog, LogLevel::Debug,
1483             ("Closing connection to '%s'", leafName.get()));
1484   }
1485
1486   // At this stage, we may still have statements that need to be
1487   // finalized. Attempt to close the database connection. This will
1488   // always disconnect any virtual tables and cleanly finalize their
1489   // internal statements. Once this is done, closing may fail due to
1490   // unfinalized client statements, in which case we need to finalize
1491   // these statements and close again.
1492   {
1493     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
1494     mConnectionClosed = true;
1495   }
1496
1497   // Nothing else needs to be done if we don't have a connection here.
1498   if (!aNativeConnection) return NS_OK;
1499
1500   int srv = ::sqlite3_close(aNativeConnection);
1501
1502   if (srv == SQLITE_BUSY) {
1503     {
1504       // Nothing else should change the connection or statements status until we
1505       // are done here.
1506       SQLiteMutexAutoLock lockedScope(sharedDBMutex);
1507       // We still have non-finalized statements. Finalize them.
1508       sqlite3_stmt* stmt = nullptr;
1509       while ((stmt = ::sqlite3_next_stmt(aNativeConnection, stmt))) {
1510         MOZ_LOG(gStorageLog, LogLevel::Debug,
1511                 ("Auto-finalizing SQL statement '%s' (%p)", ::sqlite3_sql(stmt),
1512                  stmt));
1513
1514 #ifdef DEBUG
1515         SmprintfPointer msg = ::mozilla::Smprintf(
1516             "SQL statement '%s' (%p) should have been finalized before closing "
1517             "the connection",
1518             ::sqlite3_sql(stmt), stmt);
1519         NS_WARNING(msg.get());
1520 #endif  // DEBUG
1521
1522         srv = ::sqlite3_finalize(stmt);
1523
1524 #ifdef DEBUG
1525         if (srv != SQLITE_OK) {
1526           SmprintfPointer msg = ::mozilla::Smprintf(
1527               "Could not finalize SQL statement (%p)", stmt);
1528           NS_WARNING(msg.get());
1529         }
1530 #endif  // DEBUG
1531
1532         // Ensure that the loop continues properly, whether closing has
1533         // succeeded or not.
1534         if (srv == SQLITE_OK) {
1535           stmt = nullptr;
1536         }
1537       }
1538       // Scope exiting will unlock the mutex before we invoke sqlite3_close()
1539       // again, since Sqlite will try to acquire it.
1540     }
1541
1542     // Now that all statements have been finalized, we
1543     // should be able to close.
1544     srv = ::sqlite3_close(aNativeConnection);
1545     MOZ_ASSERT(false,
1546                "Had to forcibly close the database connection because not all "
1547                "the statements have been finalized.");
1548   }
1549
1550   if (srv == SQLITE_OK) {
1551     sharedDBMutex.destroy();
1552   } else {
1553     MOZ_ASSERT(false,
1554                "sqlite3_close failed. There are probably outstanding "
1555                "statements that are listed above!");
1556   }
1557
1558   return convertResultCode(srv);
1559 }
1560
1561 nsCString Connection::getFilename() { return mTelemetryFilename; }
1562
1563 int Connection::stepStatement(sqlite3* aNativeConnection,
1564                               sqlite3_stmt* aStatement) {
1565   MOZ_ASSERT(aStatement);
1566
1567   AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::stepStatement", OTHER,
1568                                    ::sqlite3_sql(aStatement));
1569
1570   bool checkedMainThread = false;
1571   TimeStamp startTime = TimeStamp::Now();
1572
1573   // The connection may have been closed if the executing statement has been
1574   // created and cached after a call to asyncClose() but before the actual
1575   // sqlite3_close().  This usually happens when other tasks using cached
1576   // statements are asynchronously scheduled for execution and any of them ends
1577   // up after asyncClose. See bug 728653 for details.
1578   if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1579
1580   (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1581
1582   int srv;
1583   while ((srv = ::sqlite3_step(aStatement)) == SQLITE_LOCKED_SHAREDCACHE) {
1584     if (!checkedMainThread) {
1585       checkedMainThread = true;
1586       if (::NS_IsMainThread()) {
1587         NS_WARNING("We won't allow blocking on the main thread!");
1588         break;
1589       }
1590     }
1591
1592     srv = WaitForUnlockNotify(aNativeConnection);
1593     if (srv != SQLITE_OK) {
1594       break;
1595     }
1596
1597     ::sqlite3_reset(aStatement);
1598   }
1599
1600   // Report very slow SQL statements to Telemetry
1601   TimeDuration duration = TimeStamp::Now() - startTime;
1602   const uint32_t threshold = NS_IsMainThread()
1603                                  ? Telemetry::kSlowSQLThresholdForMainThread
1604                                  : Telemetry::kSlowSQLThresholdForHelperThreads;
1605   if (duration.ToMilliseconds() >= threshold) {
1606     nsDependentCString statementString(::sqlite3_sql(aStatement));
1607     Telemetry::RecordSlowSQLStatement(
1608         statementString, mTelemetryFilename,
1609         static_cast<uint32_t>(duration.ToMilliseconds()));
1610   }
1611
1612   (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1613   // Drop off the extended result bits of the result code.
1614   return srv & 0xFF;
1615 }
1616
1617 int Connection::prepareStatement(sqlite3* aNativeConnection,
1618                                  const nsCString& aSQL, sqlite3_stmt** _stmt) {
1619   // We should not even try to prepare statements after the connection has
1620   // been closed.
1621   if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1622
1623   bool checkedMainThread = false;
1624
1625   (void)::sqlite3_extended_result_codes(aNativeConnection, 1);
1626
1627   int srv;
1628   while ((srv = ::sqlite3_prepare_v2(aNativeConnection, aSQL.get(), -1, _stmt,
1629                                      nullptr)) == SQLITE_LOCKED_SHAREDCACHE) {
1630     if (!checkedMainThread) {
1631       checkedMainThread = true;
1632       if (::NS_IsMainThread()) {
1633         NS_WARNING("We won't allow blocking on the main thread!");
1634         break;
1635       }
1636     }
1637
1638     srv = WaitForUnlockNotify(aNativeConnection);
1639     if (srv != SQLITE_OK) {
1640       break;
1641     }
1642   }
1643
1644   if (srv != SQLITE_OK) {
1645     nsCString warnMsg;
1646     warnMsg.AppendLiteral("The SQL statement '");
1647     warnMsg.Append(aSQL);
1648     warnMsg.AppendLiteral("' could not be compiled due to an error: ");
1649     warnMsg.Append(::sqlite3_errmsg(aNativeConnection));
1650
1651 #ifdef DEBUG
1652     NS_WARNING(warnMsg.get());
1653 #endif
1654     MOZ_LOG(gStorageLog, LogLevel::Error, ("%s", warnMsg.get()));
1655   }
1656
1657   (void)::sqlite3_extended_result_codes(aNativeConnection, 0);
1658   // Drop off the extended result bits of the result code.
1659   int rc = srv & 0xFF;
1660   // sqlite will return OK on a comment only string and set _stmt to nullptr.
1661   // The callers of this function are used to only checking the return value,
1662   // so it is safer to return an error code.
1663   if (rc == SQLITE_OK && *_stmt == nullptr) {
1664     return SQLITE_MISUSE;
1665   }
1666
1667   return rc;
1668 }
1669
1670 int Connection::executeSql(sqlite3* aNativeConnection, const char* aSqlString) {
1671   if (!isConnectionReadyOnThisThread()) return SQLITE_MISUSE;
1672
1673   AUTO_PROFILER_LABEL_DYNAMIC_CSTR("Connection::executeSql", OTHER, aSqlString);
1674
1675   TimeStamp startTime = TimeStamp::Now();
1676   int srv =
1677       ::sqlite3_exec(aNativeConnection, aSqlString, nullptr, nullptr, nullptr);
1678   RecordQueryStatus(srv);
1679
1680   // Report very slow SQL statements to Telemetry
1681   TimeDuration duration = TimeStamp::Now() - startTime;
1682   const uint32_t threshold = NS_IsMainThread()
1683                                  ? Telemetry::kSlowSQLThresholdForMainThread
1684                                  : Telemetry::kSlowSQLThresholdForHelperThreads;
1685   if (duration.ToMilliseconds() >= threshold) {
1686     nsDependentCString statementString(aSqlString);
1687     Telemetry::RecordSlowSQLStatement(
1688         statementString, mTelemetryFilename,
1689         static_cast<uint32_t>(duration.ToMilliseconds()));
1690   }
1691
1692   return srv;
1693 }
1694
1695 ////////////////////////////////////////////////////////////////////////////////
1696 //// nsIInterfaceRequestor
1697
1698 NS_IMETHODIMP
1699 Connection::GetInterface(const nsIID& aIID, void** _result) {
1700   if (aIID.Equals(NS_GET_IID(nsIEventTarget))) {
1701     nsIEventTarget* background = getAsyncExecutionTarget();
1702     NS_IF_ADDREF(background);
1703     *_result = background;
1704     return NS_OK;
1705   }
1706   return NS_ERROR_NO_INTERFACE;
1707 }
1708
1709 ////////////////////////////////////////////////////////////////////////////////
1710 //// mozIStorageConnection
1711
1712 NS_IMETHODIMP
1713 Connection::Close() {
1714   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1715   if (NS_FAILED(rv)) {
1716     return rv;
1717   }
1718   return synchronousClose();
1719 }
1720
1721 nsresult Connection::synchronousClose() {
1722   if (!connectionReady()) {
1723     return NS_ERROR_NOT_INITIALIZED;
1724   }
1725
1726 #ifdef DEBUG
1727   // Since we're accessing mAsyncExecutionThread, we need to be on the opener
1728   // event target. We make this check outside of debug code below in
1729   // setClosedState, but this is here to be explicit.
1730   MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
1731 #endif  // DEBUG
1732
1733   // Make sure we have not executed any asynchronous statements.
1734   // If this fails, the mDBConn may be left open, resulting in a leak.
1735   // We'll try to finalize the pending statements and close the connection.
1736   if (isAsyncExecutionThreadAvailable()) {
1737 #ifdef DEBUG
1738     if (NS_IsMainThread()) {
1739       nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
1740       Unused << xpc->DebugDumpJSStack(false, false, false);
1741     }
1742 #endif
1743     MOZ_ASSERT(false,
1744                "Close() was invoked on a connection that executed asynchronous "
1745                "statements. "
1746                "Should have used asyncClose().");
1747     // Try to close the database regardless, to free up resources.
1748     Unused << SpinningSynchronousClose();
1749     return NS_ERROR_UNEXPECTED;
1750   }
1751
1752   // setClosedState nullifies our connection pointer, so we take a raw pointer
1753   // off it, to pass it through the close procedure.
1754   sqlite3* nativeConn = mDBConn;
1755   nsresult rv = setClosedState();
1756   NS_ENSURE_SUCCESS(rv, rv);
1757
1758   return internalClose(nativeConn);
1759 }
1760
1761 NS_IMETHODIMP
1762 Connection::SpinningSynchronousClose() {
1763   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
1764   if (NS_FAILED(rv)) {
1765     return rv;
1766   }
1767   if (!IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
1768     return NS_ERROR_NOT_SAME_THREAD;
1769   }
1770
1771   // As currently implemented, we can't spin to wait for an existing AsyncClose.
1772   // Our only existing caller will never have called close; assert if misused
1773   // so that no new callers assume this works after an AsyncClose.
1774   MOZ_DIAGNOSTIC_ASSERT(connectionReady());
1775   if (!connectionReady()) {
1776     return NS_ERROR_UNEXPECTED;
1777   }
1778
1779   RefPtr<CloseListener> listener = new CloseListener();
1780   rv = AsyncClose(listener);
1781   NS_ENSURE_SUCCESS(rv, rv);
1782   MOZ_ALWAYS_TRUE(
1783       SpinEventLoopUntil("storage::Connection::SpinningSynchronousClose"_ns,
1784                          [&]() { return listener->mClosed; }));
1785   MOZ_ASSERT(isClosed(), "The connection should be closed at this point");
1786
1787   return rv;
1788 }
1789
1790 NS_IMETHODIMP
1791 Connection::AsyncClose(mozIStorageCompletionCallback* aCallback) {
1792   NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
1793   // Check if AsyncClose or Close were already invoked.
1794   if (!connectionReady()) {
1795     return NS_ERROR_NOT_INITIALIZED;
1796   }
1797   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1798   if (NS_FAILED(rv)) {
1799     return rv;
1800   }
1801
1802   // The two relevant factors at this point are whether we have a database
1803   // connection and whether we have an async execution thread.  Here's what the
1804   // states mean and how we handle them:
1805   //
1806   // - (mDBConn && asyncThread): The expected case where we are either an
1807   //   async connection or a sync connection that has been used asynchronously.
1808   //   Either way the caller must call us and not Close().  Nothing surprising
1809   //   about this.  We'll dispatch AsyncCloseConnection to the already-existing
1810   //   async thread.
1811   //
1812   // - (mDBConn && !asyncThread): A somewhat unusual case where the caller
1813   //   opened the connection synchronously and was planning to use it
1814   //   asynchronously, but never got around to using it asynchronously before
1815   //   needing to shutdown.  This has been observed to happen for the cookie
1816   //   service in a case where Firefox shuts itself down almost immediately
1817   //   after startup (for unknown reasons).  In the Firefox shutdown case,
1818   //   we may also fail to create a new async execution thread if one does not
1819   //   already exist.  (nsThreadManager will refuse to create new threads when
1820   //   it has already been told to shutdown.)  As such, we need to handle a
1821   //   failure to create the async execution thread by falling back to
1822   //   synchronous Close() and also dispatching the completion callback because
1823   //   at least Places likes to spin a nested event loop that depends on the
1824   //   callback being invoked.
1825   //
1826   //   Note that we have considered not trying to spin up the async execution
1827   //   thread in this case if it does not already exist, but the overhead of
1828   //   thread startup (if successful) is significantly less expensive than the
1829   //   worst-case potential I/O hit of synchronously closing a database when we
1830   //   could close it asynchronously.
1831   //
1832   // - (!mDBConn && asyncThread): This happens in some but not all cases where
1833   //   OpenAsyncDatabase encountered a problem opening the database.  If it
1834   //   happened in all cases AsyncInitDatabase would just shut down the thread
1835   //   directly and we would avoid this case.  But it doesn't, so for simplicity
1836   //   and consistency AsyncCloseConnection knows how to handle this and we
1837   //   act like this was the (mDBConn && asyncThread) case in this method.
1838   //
1839   // - (!mDBConn && !asyncThread): The database was never successfully opened or
1840   //   Close() or AsyncClose() has already been called (at least) once.  This is
1841   //   undeniably a misuse case by the caller.  We could optimize for this
1842   //   case by adding an additional check of mAsyncExecutionThread without using
1843   //   getAsyncExecutionTarget() to avoid wastefully creating a thread just to
1844   //   shut it down.  But this complicates the method for broken caller code
1845   //   whereas we're still correct and safe without the special-case.
1846   nsIEventTarget* asyncThread = getAsyncExecutionTarget();
1847
1848   // Create our callback event if we were given a callback.  This will
1849   // eventually be dispatched in all cases, even if we fall back to Close() and
1850   // the database wasn't open and we return an error.  The rationale is that
1851   // no existing consumer checks our return value and several of them like to
1852   // spin nested event loops until the callback fires.  Given that, it seems
1853   // preferable for us to dispatch the callback in all cases.  (Except the
1854   // wrong thread misuse case we bailed on up above.  But that's okay because
1855   // that is statically wrong whereas these edge cases are dynamic.)
1856   nsCOMPtr<nsIRunnable> completeEvent;
1857   if (aCallback) {
1858     completeEvent = newCompletionEvent(aCallback);
1859   }
1860
1861   if (!asyncThread) {
1862     // We were unable to create an async thread, so we need to fall back to
1863     // using normal Close().  Since there is no async thread, Close() will
1864     // not complain about that.  (Close() may, however, complain if the
1865     // connection is closed, but that's okay.)
1866     if (completeEvent) {
1867       // Closing the database is more important than returning an error code
1868       // about a failure to dispatch, especially because all existing native
1869       // callers ignore our return value.
1870       Unused << NS_DispatchToMainThread(completeEvent.forget());
1871     }
1872     MOZ_ALWAYS_SUCCEEDS(synchronousClose());
1873     // Return a success inconditionally here, since Close() is unlikely to fail
1874     // and we want to reassure the consumer that its callback will be invoked.
1875     return NS_OK;
1876   }
1877
1878   // If we're closing the connection during shutdown, and there is an
1879   // interruptible statement running on the helper thread, issue a
1880   // sqlite3_interrupt() to avoid crashing when that statement takes a long
1881   // time (for example a vacuum).
1882   if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed) &&
1883       mInterruptible && mIsStatementOnHelperThreadInterruptible) {
1884     MOZ_ASSERT(!isClosing(), "Must not be closing, see Interrupt()");
1885     DebugOnly<nsresult> rv2 = Interrupt();
1886     MOZ_ASSERT(NS_SUCCEEDED(rv2));
1887   }
1888
1889   // setClosedState nullifies our connection pointer, so we take a raw pointer
1890   // off it, to pass it through the close procedure.
1891   sqlite3* nativeConn = mDBConn;
1892   rv = setClosedState();
1893   NS_ENSURE_SUCCESS(rv, rv);
1894
1895   // Create and dispatch our close event to the background thread.
1896   nsCOMPtr<nsIRunnable> closeEvent =
1897       new AsyncCloseConnection(this, nativeConn, completeEvent);
1898   rv = asyncThread->Dispatch(closeEvent, NS_DISPATCH_NORMAL);
1899   NS_ENSURE_SUCCESS(rv, rv);
1900
1901   return NS_OK;
1902 }
1903
1904 NS_IMETHODIMP
1905 Connection::AsyncClone(bool aReadOnly,
1906                        mozIStorageCompletionCallback* aCallback) {
1907   AUTO_PROFILER_LABEL("Connection::AsyncClone", OTHER);
1908
1909   NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
1910   if (!connectionReady()) {
1911     return NS_ERROR_NOT_INITIALIZED;
1912   }
1913   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
1914   if (NS_FAILED(rv)) {
1915     return rv;
1916   }
1917   if (!mDatabaseFile) return NS_ERROR_UNEXPECTED;
1918
1919   int flags = mFlags;
1920   if (aReadOnly) {
1921     // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
1922     flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY;
1923     // Turn off SQLITE_OPEN_CREATE.
1924     flags = (~SQLITE_OPEN_CREATE & flags);
1925   }
1926
1927   // The cloned connection will still implement the synchronous API, but throw
1928   // if any synchronous methods are called on the main thread.
1929   RefPtr<Connection> clone =
1930       new Connection(mStorageService, flags, ASYNCHRONOUS, mTelemetryFilename);
1931
1932   RefPtr<AsyncInitializeClone> initEvent =
1933       new AsyncInitializeClone(this, clone, aReadOnly, aCallback);
1934   // Dispatch to our async thread, since the originating connection must remain
1935   // valid and open for the whole cloning process.  This also ensures we are
1936   // properly serialized with a `close` operation, rather than race with it.
1937   nsCOMPtr<nsIEventTarget> target = getAsyncExecutionTarget();
1938   if (!target) {
1939     return NS_ERROR_UNEXPECTED;
1940   }
1941   return target->Dispatch(initEvent, NS_DISPATCH_NORMAL);
1942 }
1943
1944 nsresult Connection::initializeClone(Connection* aClone, bool aReadOnly) {
1945   nsresult rv;
1946   if (!mStorageKey.IsEmpty()) {
1947     rv = aClone->initialize(mStorageKey, mName);
1948   } else if (mFileURL) {
1949     rv = aClone->initialize(mFileURL);
1950   } else {
1951     rv = aClone->initialize(mDatabaseFile);
1952   }
1953   if (NS_FAILED(rv)) {
1954     return rv;
1955   }
1956
1957   auto guard = MakeScopeExit([&]() { aClone->initializeFailed(); });
1958
1959   rv = aClone->SetDefaultTransactionType(mDefaultTransactionType);
1960   NS_ENSURE_SUCCESS(rv, rv);
1961
1962   // Re-attach on-disk databases that were attached to the original connection.
1963   {
1964     nsCOMPtr<mozIStorageStatement> stmt;
1965     rv = CreateStatement("PRAGMA database_list"_ns, getter_AddRefs(stmt));
1966     NS_ENSURE_SUCCESS(rv, rv);
1967     bool hasResult = false;
1968     while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
1969       nsAutoCString name;
1970       rv = stmt->GetUTF8String(1, name);
1971       if (NS_SUCCEEDED(rv) && !name.EqualsLiteral("main") &&
1972           !name.EqualsLiteral("temp")) {
1973         nsCString path;
1974         rv = stmt->GetUTF8String(2, path);
1975         if (NS_SUCCEEDED(rv) && !path.IsEmpty()) {
1976           nsCOMPtr<mozIStorageStatement> attachStmt;
1977           rv = aClone->CreateStatement("ATTACH DATABASE :path AS "_ns + name,
1978                                        getter_AddRefs(attachStmt));
1979           NS_ENSURE_SUCCESS(rv, rv);
1980           rv = attachStmt->BindUTF8StringByName("path"_ns, path);
1981           NS_ENSURE_SUCCESS(rv, rv);
1982           rv = attachStmt->Execute();
1983           NS_ENSURE_SUCCESS(rv, rv);
1984         }
1985       }
1986     }
1987   }
1988
1989   // Copy over pragmas from the original connection.
1990   // LIMITATION WARNING!  Many of these pragmas are actually scoped to the
1991   // schema ("main" and any other attached databases), and this implmentation
1992   // fails to propagate them.  This is being addressed on trunk.
1993   static const char* pragmas[] = {
1994       "cache_size",  "temp_store",         "foreign_keys", "journal_size_limit",
1995       "synchronous", "wal_autocheckpoint", "busy_timeout"};
1996   for (auto& pragma : pragmas) {
1997     // Read-only connections just need cache_size and temp_store pragmas.
1998     if (aReadOnly && ::strcmp(pragma, "cache_size") != 0 &&
1999         ::strcmp(pragma, "temp_store") != 0) {
2000       continue;
2001     }
2002
2003     nsAutoCString pragmaQuery("PRAGMA ");
2004     pragmaQuery.Append(pragma);
2005     nsCOMPtr<mozIStorageStatement> stmt;
2006     rv = CreateStatement(pragmaQuery, getter_AddRefs(stmt));
2007     NS_ENSURE_SUCCESS(rv, rv);
2008     bool hasResult = false;
2009     if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2010       pragmaQuery.AppendLiteral(" = ");
2011       pragmaQuery.AppendInt(stmt->AsInt32(0));
2012       rv = aClone->ExecuteSimpleSQL(pragmaQuery);
2013       NS_ENSURE_SUCCESS(rv, rv);
2014     }
2015   }
2016
2017   // Copy over temporary tables, triggers, and views from the original
2018   // connections. Entities in `sqlite_temp_master` are only visible to the
2019   // connection that created them.
2020   if (!aReadOnly) {
2021     rv = aClone->ExecuteSimpleSQL("BEGIN TRANSACTION"_ns);
2022     NS_ENSURE_SUCCESS(rv, rv);
2023
2024     nsCOMPtr<mozIStorageStatement> stmt;
2025     rv = CreateStatement(nsLiteralCString("SELECT sql FROM sqlite_temp_master "
2026                                           "WHERE type IN ('table', 'view', "
2027                                           "'index', 'trigger')"),
2028                          getter_AddRefs(stmt));
2029     // Propagate errors, because failing to copy triggers might cause schema
2030     // coherency issues when writing to the database from the cloned connection.
2031     NS_ENSURE_SUCCESS(rv, rv);
2032     bool hasResult = false;
2033     while (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2034       nsAutoCString query;
2035       rv = stmt->GetUTF8String(0, query);
2036       NS_ENSURE_SUCCESS(rv, rv);
2037
2038       // The `CREATE` SQL statements in `sqlite_temp_master` omit the `TEMP`
2039       // keyword. We need to add it back, or we'll recreate temporary entities
2040       // as persistent ones. `sqlite_temp_master` also holds `CREATE INDEX`
2041       // statements, but those don't need `TEMP` keywords.
2042       if (StringBeginsWith(query, "CREATE TABLE "_ns) ||
2043           StringBeginsWith(query, "CREATE TRIGGER "_ns) ||
2044           StringBeginsWith(query, "CREATE VIEW "_ns)) {
2045         query.Replace(0, 6, "CREATE TEMP");
2046       }
2047
2048       rv = aClone->ExecuteSimpleSQL(query);
2049       NS_ENSURE_SUCCESS(rv, rv);
2050     }
2051
2052     rv = aClone->ExecuteSimpleSQL("COMMIT"_ns);
2053     NS_ENSURE_SUCCESS(rv, rv);
2054   }
2055
2056   // Copy any functions that have been added to this connection.
2057   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2058   for (const auto& entry : mFunctions) {
2059     const nsACString& key = entry.GetKey();
2060     Connection::FunctionInfo data = entry.GetData();
2061
2062     rv = aClone->CreateFunction(key, data.numArgs, data.function);
2063     if (NS_FAILED(rv)) {
2064       NS_WARNING("Failed to copy function to cloned connection");
2065     }
2066   }
2067
2068   // Load SQLite extensions that were on this connection.
2069   // Copy into an array rather than holding the mutex while we load extensions.
2070   nsTArray<nsCString> loadedExtensions;
2071   {
2072     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2073     AppendToArray(loadedExtensions, mLoadedExtensions);
2074   }
2075   for (const auto& extension : loadedExtensions) {
2076     (void)aClone->LoadExtension(extension, nullptr);
2077   }
2078
2079   guard.release();
2080   return NS_OK;
2081 }
2082
2083 NS_IMETHODIMP
2084 Connection::Clone(bool aReadOnly, mozIStorageConnection** _connection) {
2085   MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2086
2087   AUTO_PROFILER_LABEL("Connection::Clone", OTHER);
2088
2089   if (!connectionReady()) {
2090     return NS_ERROR_NOT_INITIALIZED;
2091   }
2092   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2093   if (NS_FAILED(rv)) {
2094     return rv;
2095   }
2096
2097   int flags = mFlags;
2098   if (aReadOnly) {
2099     // Turn off SQLITE_OPEN_READWRITE, and set SQLITE_OPEN_READONLY.
2100     flags = (~SQLITE_OPEN_READWRITE & flags) | SQLITE_OPEN_READONLY;
2101     // Turn off SQLITE_OPEN_CREATE.
2102     flags = (~SQLITE_OPEN_CREATE & flags);
2103   }
2104
2105   RefPtr<Connection> clone =
2106       new Connection(mStorageService, flags, mSupportedOperations,
2107                      mTelemetryFilename, mInterruptible);
2108
2109   rv = initializeClone(clone, aReadOnly);
2110   if (NS_FAILED(rv)) {
2111     return rv;
2112   }
2113
2114   NS_IF_ADDREF(*_connection = clone);
2115   return NS_OK;
2116 }
2117
2118 NS_IMETHODIMP
2119 Connection::Interrupt() {
2120   MOZ_ASSERT(mInterruptible, "Interrupt method not allowed");
2121   MOZ_ASSERT_IF(SYNCHRONOUS == mSupportedOperations,
2122                 !IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2123   MOZ_ASSERT_IF(ASYNCHRONOUS == mSupportedOperations,
2124                 IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2125
2126   if (!connectionReady()) {
2127     return NS_ERROR_NOT_INITIALIZED;
2128   }
2129
2130   if (isClosing()) {  // Closing already in asynchronous case
2131     return NS_OK;
2132   }
2133
2134   {
2135     // As stated on https://www.sqlite.org/c3ref/interrupt.html,
2136     // it is not safe to call sqlite3_interrupt() when
2137     // database connection is closed or might close before
2138     // sqlite3_interrupt() returns.
2139     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2140     if (!isClosed(lockedScope)) {
2141       MOZ_ASSERT(mDBConn);
2142       ::sqlite3_interrupt(mDBConn);
2143     }
2144   }
2145
2146   return NS_OK;
2147 }
2148
2149 NS_IMETHODIMP
2150 Connection::AsyncVacuum(mozIStorageCompletionCallback* aCallback,
2151                         bool aUseIncremental, int32_t aSetPageSize) {
2152   NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2153   // Abort if we're shutting down.
2154   if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2155     return NS_ERROR_ABORT;
2156   }
2157   // Check if AsyncClose or Close were already invoked.
2158   if (!connectionReady()) {
2159     return NS_ERROR_NOT_INITIALIZED;
2160   }
2161   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2162   if (NS_FAILED(rv)) {
2163     return rv;
2164   }
2165   nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2166   if (!asyncThread) {
2167     return NS_ERROR_NOT_INITIALIZED;
2168   }
2169
2170   // Create and dispatch our vacuum event to the background thread.
2171   nsCOMPtr<nsIRunnable> vacuumEvent =
2172       new AsyncVacuumEvent(this, aCallback, aUseIncremental, aSetPageSize);
2173   rv = asyncThread->Dispatch(vacuumEvent, NS_DISPATCH_NORMAL);
2174   NS_ENSURE_SUCCESS(rv, rv);
2175
2176   return NS_OK;
2177 }
2178
2179 NS_IMETHODIMP
2180 Connection::GetDefaultPageSize(int32_t* _defaultPageSize) {
2181   *_defaultPageSize = Service::kDefaultPageSize;
2182   return NS_OK;
2183 }
2184
2185 NS_IMETHODIMP
2186 Connection::GetConnectionReady(bool* _ready) {
2187   MOZ_ASSERT(IsOnCurrentSerialEventTarget(eventTargetOpenedOn));
2188   *_ready = connectionReady();
2189   return NS_OK;
2190 }
2191
2192 NS_IMETHODIMP
2193 Connection::GetDatabaseFile(nsIFile** _dbFile) {
2194   if (!connectionReady()) {
2195     return NS_ERROR_NOT_INITIALIZED;
2196   }
2197   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2198   if (NS_FAILED(rv)) {
2199     return rv;
2200   }
2201
2202   NS_IF_ADDREF(*_dbFile = mDatabaseFile);
2203
2204   return NS_OK;
2205 }
2206
2207 NS_IMETHODIMP
2208 Connection::GetLastInsertRowID(int64_t* _id) {
2209   if (!connectionReady()) {
2210     return NS_ERROR_NOT_INITIALIZED;
2211   }
2212   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2213   if (NS_FAILED(rv)) {
2214     return rv;
2215   }
2216
2217   sqlite_int64 id = ::sqlite3_last_insert_rowid(mDBConn);
2218   *_id = id;
2219
2220   return NS_OK;
2221 }
2222
2223 NS_IMETHODIMP
2224 Connection::GetAffectedRows(int32_t* _rows) {
2225   if (!connectionReady()) {
2226     return NS_ERROR_NOT_INITIALIZED;
2227   }
2228   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2229   if (NS_FAILED(rv)) {
2230     return rv;
2231   }
2232
2233   *_rows = ::sqlite3_changes(mDBConn);
2234
2235   return NS_OK;
2236 }
2237
2238 NS_IMETHODIMP
2239 Connection::GetLastError(int32_t* _error) {
2240   if (!connectionReady()) {
2241     return NS_ERROR_NOT_INITIALIZED;
2242   }
2243   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2244   if (NS_FAILED(rv)) {
2245     return rv;
2246   }
2247
2248   *_error = ::sqlite3_errcode(mDBConn);
2249
2250   return NS_OK;
2251 }
2252
2253 NS_IMETHODIMP
2254 Connection::GetLastErrorString(nsACString& _errorString) {
2255   if (!connectionReady()) {
2256     return NS_ERROR_NOT_INITIALIZED;
2257   }
2258   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2259   if (NS_FAILED(rv)) {
2260     return rv;
2261   }
2262
2263   const char* serr = ::sqlite3_errmsg(mDBConn);
2264   _errorString.Assign(serr);
2265
2266   return NS_OK;
2267 }
2268
2269 NS_IMETHODIMP
2270 Connection::GetSchemaVersion(int32_t* _version) {
2271   if (!connectionReady()) {
2272     return NS_ERROR_NOT_INITIALIZED;
2273   }
2274   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2275   if (NS_FAILED(rv)) {
2276     return rv;
2277   }
2278
2279   nsCOMPtr<mozIStorageStatement> stmt;
2280   (void)CreateStatement("PRAGMA user_version"_ns, getter_AddRefs(stmt));
2281   NS_ENSURE_TRUE(stmt, NS_ERROR_OUT_OF_MEMORY);
2282
2283   *_version = 0;
2284   bool hasResult;
2285   if (NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2286     *_version = stmt->AsInt32(0);
2287   }
2288
2289   return NS_OK;
2290 }
2291
2292 NS_IMETHODIMP
2293 Connection::SetSchemaVersion(int32_t aVersion) {
2294   if (!connectionReady()) {
2295     return NS_ERROR_NOT_INITIALIZED;
2296   }
2297   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2298   if (NS_FAILED(rv)) {
2299     return rv;
2300   }
2301
2302   nsAutoCString stmt("PRAGMA user_version = "_ns);
2303   stmt.AppendInt(aVersion);
2304
2305   return ExecuteSimpleSQL(stmt);
2306 }
2307
2308 NS_IMETHODIMP
2309 Connection::CreateStatement(const nsACString& aSQLStatement,
2310                             mozIStorageStatement** _stmt) {
2311   NS_ENSURE_ARG_POINTER(_stmt);
2312   if (!connectionReady()) {
2313     return NS_ERROR_NOT_INITIALIZED;
2314   }
2315   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2316   if (NS_FAILED(rv)) {
2317     return rv;
2318   }
2319
2320   RefPtr<Statement> statement(new Statement());
2321   NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
2322
2323   rv = statement->initialize(this, mDBConn, aSQLStatement);
2324   NS_ENSURE_SUCCESS(rv, rv);
2325
2326   Statement* rawPtr;
2327   statement.forget(&rawPtr);
2328   *_stmt = rawPtr;
2329   return NS_OK;
2330 }
2331
2332 NS_IMETHODIMP
2333 Connection::CreateAsyncStatement(const nsACString& aSQLStatement,
2334                                  mozIStorageAsyncStatement** _stmt) {
2335   NS_ENSURE_ARG_POINTER(_stmt);
2336   if (!connectionReady()) {
2337     return NS_ERROR_NOT_INITIALIZED;
2338   }
2339   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2340   if (NS_FAILED(rv)) {
2341     return rv;
2342   }
2343
2344   RefPtr<AsyncStatement> statement(new AsyncStatement());
2345   NS_ENSURE_TRUE(statement, NS_ERROR_OUT_OF_MEMORY);
2346
2347   rv = statement->initialize(this, mDBConn, aSQLStatement);
2348   NS_ENSURE_SUCCESS(rv, rv);
2349
2350   AsyncStatement* rawPtr;
2351   statement.forget(&rawPtr);
2352   *_stmt = rawPtr;
2353   return NS_OK;
2354 }
2355
2356 NS_IMETHODIMP
2357 Connection::ExecuteSimpleSQL(const nsACString& aSQLStatement) {
2358   CHECK_MAINTHREAD_ABUSE();
2359   if (!connectionReady()) {
2360     return NS_ERROR_NOT_INITIALIZED;
2361   }
2362   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2363   if (NS_FAILED(rv)) {
2364     return rv;
2365   }
2366
2367   int srv = executeSql(mDBConn, PromiseFlatCString(aSQLStatement).get());
2368   return convertResultCode(srv);
2369 }
2370
2371 NS_IMETHODIMP
2372 Connection::ExecuteAsync(
2373     const nsTArray<RefPtr<mozIStorageBaseStatement>>& aStatements,
2374     mozIStorageStatementCallback* aCallback,
2375     mozIStoragePendingStatement** _handle) {
2376   nsTArray<StatementData> stmts(aStatements.Length());
2377   for (uint32_t i = 0; i < aStatements.Length(); i++) {
2378     nsCOMPtr<StorageBaseStatementInternal> stmt =
2379         do_QueryInterface(aStatements[i]);
2380     NS_ENSURE_STATE(stmt);
2381
2382     // Obtain our StatementData.
2383     StatementData data;
2384     nsresult rv = stmt->getAsynchronousStatementData(data);
2385     NS_ENSURE_SUCCESS(rv, rv);
2386
2387     NS_ASSERTION(stmt->getOwner() == this,
2388                  "Statement must be from this database connection!");
2389
2390     // Now append it to our array.
2391     stmts.AppendElement(data);
2392   }
2393
2394   // Dispatch to the background
2395   return AsyncExecuteStatements::execute(std::move(stmts), this, mDBConn,
2396                                          aCallback, _handle);
2397 }
2398
2399 NS_IMETHODIMP
2400 Connection::ExecuteSimpleSQLAsync(const nsACString& aSQLStatement,
2401                                   mozIStorageStatementCallback* aCallback,
2402                                   mozIStoragePendingStatement** _handle) {
2403   NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2404
2405   nsCOMPtr<mozIStorageAsyncStatement> stmt;
2406   nsresult rv = CreateAsyncStatement(aSQLStatement, getter_AddRefs(stmt));
2407   if (NS_FAILED(rv)) {
2408     return rv;
2409   }
2410
2411   nsCOMPtr<mozIStoragePendingStatement> pendingStatement;
2412   rv = stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement));
2413   if (NS_FAILED(rv)) {
2414     return rv;
2415   }
2416
2417   pendingStatement.forget(_handle);
2418   return rv;
2419 }
2420
2421 NS_IMETHODIMP
2422 Connection::TableExists(const nsACString& aTableName, bool* _exists) {
2423   return databaseElementExists(TABLE, aTableName, _exists);
2424 }
2425
2426 NS_IMETHODIMP
2427 Connection::IndexExists(const nsACString& aIndexName, bool* _exists) {
2428   return databaseElementExists(INDEX, aIndexName, _exists);
2429 }
2430
2431 NS_IMETHODIMP
2432 Connection::GetTransactionInProgress(bool* _inProgress) {
2433   if (!connectionReady()) {
2434     return NS_ERROR_NOT_INITIALIZED;
2435   }
2436   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2437   if (NS_FAILED(rv)) {
2438     return rv;
2439   }
2440
2441   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2442   *_inProgress = transactionInProgress(lockedScope);
2443   return NS_OK;
2444 }
2445
2446 NS_IMETHODIMP
2447 Connection::GetDefaultTransactionType(int32_t* _type) {
2448   *_type = mDefaultTransactionType;
2449   return NS_OK;
2450 }
2451
2452 NS_IMETHODIMP
2453 Connection::SetDefaultTransactionType(int32_t aType) {
2454   NS_ENSURE_ARG_RANGE(aType, TRANSACTION_DEFERRED, TRANSACTION_EXCLUSIVE);
2455   mDefaultTransactionType = aType;
2456   return NS_OK;
2457 }
2458
2459 NS_IMETHODIMP
2460 Connection::GetVariableLimit(int32_t* _limit) {
2461   if (!connectionReady()) {
2462     return NS_ERROR_NOT_INITIALIZED;
2463   }
2464   int limit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER, -1);
2465   if (limit < 0) {
2466     return NS_ERROR_UNEXPECTED;
2467   }
2468   *_limit = limit;
2469   return NS_OK;
2470 }
2471
2472 NS_IMETHODIMP
2473 Connection::SetVariableLimit(int32_t limit) {
2474   if (!connectionReady()) {
2475     return NS_ERROR_NOT_INITIALIZED;
2476   }
2477   int oldLimit = ::sqlite3_limit(mDBConn, SQLITE_LIMIT_VARIABLE_NUMBER, limit);
2478   if (oldLimit < 0) {
2479     return NS_ERROR_UNEXPECTED;
2480   }
2481   return NS_OK;
2482 }
2483
2484 NS_IMETHODIMP
2485 Connection::BeginTransaction() {
2486   if (!connectionReady()) {
2487     return NS_ERROR_NOT_INITIALIZED;
2488   }
2489   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2490   if (NS_FAILED(rv)) {
2491     return rv;
2492   }
2493
2494   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2495   return beginTransactionInternal(lockedScope, mDBConn,
2496                                   mDefaultTransactionType);
2497 }
2498
2499 nsresult Connection::beginTransactionInternal(
2500     const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection,
2501     int32_t aTransactionType) {
2502   if (transactionInProgress(aProofOfLock)) {
2503     return NS_ERROR_FAILURE;
2504   }
2505   nsresult rv;
2506   switch (aTransactionType) {
2507     case TRANSACTION_DEFERRED:
2508       rv = convertResultCode(executeSql(aNativeConnection, "BEGIN DEFERRED"));
2509       break;
2510     case TRANSACTION_IMMEDIATE:
2511       rv = convertResultCode(executeSql(aNativeConnection, "BEGIN IMMEDIATE"));
2512       break;
2513     case TRANSACTION_EXCLUSIVE:
2514       rv = convertResultCode(executeSql(aNativeConnection, "BEGIN EXCLUSIVE"));
2515       break;
2516     default:
2517       return NS_ERROR_ILLEGAL_VALUE;
2518   }
2519   return rv;
2520 }
2521
2522 NS_IMETHODIMP
2523 Connection::CommitTransaction() {
2524   if (!connectionReady()) {
2525     return NS_ERROR_NOT_INITIALIZED;
2526   }
2527   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2528   if (NS_FAILED(rv)) {
2529     return rv;
2530   }
2531
2532   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2533   return commitTransactionInternal(lockedScope, mDBConn);
2534 }
2535
2536 nsresult Connection::commitTransactionInternal(
2537     const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2538   if (!transactionInProgress(aProofOfLock)) {
2539     return NS_ERROR_UNEXPECTED;
2540   }
2541   nsresult rv =
2542       convertResultCode(executeSql(aNativeConnection, "COMMIT TRANSACTION"));
2543   return rv;
2544 }
2545
2546 NS_IMETHODIMP
2547 Connection::RollbackTransaction() {
2548   if (!connectionReady()) {
2549     return NS_ERROR_NOT_INITIALIZED;
2550   }
2551   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2552   if (NS_FAILED(rv)) {
2553     return rv;
2554   }
2555
2556   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2557   return rollbackTransactionInternal(lockedScope, mDBConn);
2558 }
2559
2560 nsresult Connection::rollbackTransactionInternal(
2561     const SQLiteMutexAutoLock& aProofOfLock, sqlite3* aNativeConnection) {
2562   if (!transactionInProgress(aProofOfLock)) {
2563     return NS_ERROR_UNEXPECTED;
2564   }
2565
2566   nsresult rv =
2567       convertResultCode(executeSql(aNativeConnection, "ROLLBACK TRANSACTION"));
2568   return rv;
2569 }
2570
2571 NS_IMETHODIMP
2572 Connection::CreateTable(const char* aTableName, const char* aTableSchema) {
2573   if (!connectionReady()) {
2574     return NS_ERROR_NOT_INITIALIZED;
2575   }
2576   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2577   if (NS_FAILED(rv)) {
2578     return rv;
2579   }
2580
2581   SmprintfPointer buf =
2582       ::mozilla::Smprintf("CREATE TABLE %s (%s)", aTableName, aTableSchema);
2583   if (!buf) return NS_ERROR_OUT_OF_MEMORY;
2584
2585   int srv = executeSql(mDBConn, buf.get());
2586
2587   return convertResultCode(srv);
2588 }
2589
2590 NS_IMETHODIMP
2591 Connection::CreateFunction(const nsACString& aFunctionName,
2592                            int32_t aNumArguments,
2593                            mozIStorageFunction* aFunction) {
2594   if (!connectionReady()) {
2595     return NS_ERROR_NOT_INITIALIZED;
2596   }
2597   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2598   if (NS_FAILED(rv)) {
2599     return rv;
2600   }
2601
2602   // Check to see if this function is already defined.  We only check the name
2603   // because a function can be defined with the same body but different names.
2604   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2605   NS_ENSURE_FALSE(mFunctions.Contains(aFunctionName), NS_ERROR_FAILURE);
2606
2607   int srv = ::sqlite3_create_function(
2608       mDBConn, nsPromiseFlatCString(aFunctionName).get(), aNumArguments,
2609       SQLITE_ANY, aFunction, basicFunctionHelper, nullptr, nullptr);
2610   if (srv != SQLITE_OK) return convertResultCode(srv);
2611
2612   FunctionInfo info = {aFunction, aNumArguments};
2613   mFunctions.InsertOrUpdate(aFunctionName, info);
2614
2615   return NS_OK;
2616 }
2617
2618 NS_IMETHODIMP
2619 Connection::RemoveFunction(const nsACString& aFunctionName) {
2620   if (!connectionReady()) {
2621     return NS_ERROR_NOT_INITIALIZED;
2622   }
2623   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2624   if (NS_FAILED(rv)) {
2625     return rv;
2626   }
2627
2628   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2629   NS_ENSURE_TRUE(mFunctions.Get(aFunctionName, nullptr), NS_ERROR_FAILURE);
2630
2631   int srv = ::sqlite3_create_function(
2632       mDBConn, nsPromiseFlatCString(aFunctionName).get(), 0, SQLITE_ANY,
2633       nullptr, nullptr, nullptr, nullptr);
2634   if (srv != SQLITE_OK) return convertResultCode(srv);
2635
2636   mFunctions.Remove(aFunctionName);
2637
2638   return NS_OK;
2639 }
2640
2641 NS_IMETHODIMP
2642 Connection::SetProgressHandler(int32_t aGranularity,
2643                                mozIStorageProgressHandler* aHandler,
2644                                mozIStorageProgressHandler** _oldHandler) {
2645   if (!connectionReady()) {
2646     return NS_ERROR_NOT_INITIALIZED;
2647   }
2648   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2649   if (NS_FAILED(rv)) {
2650     return rv;
2651   }
2652
2653   // Return previous one
2654   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2655   NS_IF_ADDREF(*_oldHandler = mProgressHandler);
2656
2657   if (!aHandler || aGranularity <= 0) {
2658     aHandler = nullptr;
2659     aGranularity = 0;
2660   }
2661   mProgressHandler = aHandler;
2662   ::sqlite3_progress_handler(mDBConn, aGranularity, sProgressHelper, this);
2663
2664   return NS_OK;
2665 }
2666
2667 NS_IMETHODIMP
2668 Connection::RemoveProgressHandler(mozIStorageProgressHandler** _oldHandler) {
2669   if (!connectionReady()) {
2670     return NS_ERROR_NOT_INITIALIZED;
2671   }
2672   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2673   if (NS_FAILED(rv)) {
2674     return rv;
2675   }
2676
2677   // Return previous one
2678   SQLiteMutexAutoLock lockedScope(sharedDBMutex);
2679   NS_IF_ADDREF(*_oldHandler = mProgressHandler);
2680
2681   mProgressHandler = nullptr;
2682   ::sqlite3_progress_handler(mDBConn, 0, nullptr, nullptr);
2683
2684   return NS_OK;
2685 }
2686
2687 NS_IMETHODIMP
2688 Connection::SetGrowthIncrement(int32_t aChunkSize,
2689                                const nsACString& aDatabaseName) {
2690   if (!connectionReady()) {
2691     return NS_ERROR_NOT_INITIALIZED;
2692   }
2693   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2694   if (NS_FAILED(rv)) {
2695     return rv;
2696   }
2697
2698   // Bug 597215: Disk space is extremely limited on Android
2699   // so don't preallocate space. This is also not effective
2700   // on log structured file systems used by Android devices
2701 #if !defined(ANDROID) && !defined(MOZ_PLATFORM_MAEMO)
2702   // Don't preallocate if less than 500MiB is available.
2703   int64_t bytesAvailable;
2704   rv = mDatabaseFile->GetDiskSpaceAvailable(&bytesAvailable);
2705   NS_ENSURE_SUCCESS(rv, rv);
2706   if (bytesAvailable < MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH) {
2707     return NS_ERROR_FILE_TOO_BIG;
2708   }
2709
2710   int srv = ::sqlite3_file_control(
2711       mDBConn,
2712       aDatabaseName.Length() ? nsPromiseFlatCString(aDatabaseName).get()
2713                              : nullptr,
2714       SQLITE_FCNTL_CHUNK_SIZE, &aChunkSize);
2715   if (srv == SQLITE_OK) {
2716     mGrowthChunkSize = aChunkSize;
2717   }
2718 #endif
2719   return NS_OK;
2720 }
2721
2722 int32_t Connection::RemovablePagesInFreeList(const nsACString& aSchemaName) {
2723   int32_t freeListPagesCount = 0;
2724   if (!isConnectionReadyOnThisThread()) {
2725     MOZ_ASSERT(false, "Database connection is not ready");
2726     return freeListPagesCount;
2727   }
2728   {
2729     nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
2730     query.Append(aSchemaName);
2731     query.AppendLiteral(".freelist_count");
2732     nsCOMPtr<mozIStorageStatement> stmt;
2733     DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2734     MOZ_ASSERT(NS_SUCCEEDED(rv));
2735     bool hasResult = false;
2736     if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2737       freeListPagesCount = stmt->AsInt32(0);
2738     }
2739   }
2740   // If there's no chunk size set, any page is good to be removed.
2741   if (mGrowthChunkSize == 0 || freeListPagesCount == 0) {
2742     return freeListPagesCount;
2743   }
2744   int32_t pageSize;
2745   {
2746     nsAutoCString query(MOZ_STORAGE_UNIQUIFY_QUERY_STR "PRAGMA ");
2747     query.Append(aSchemaName);
2748     query.AppendLiteral(".page_size");
2749     nsCOMPtr<mozIStorageStatement> stmt;
2750     DebugOnly<nsresult> rv = CreateStatement(query, getter_AddRefs(stmt));
2751     MOZ_ASSERT(NS_SUCCEEDED(rv));
2752     bool hasResult = false;
2753     if (stmt && NS_SUCCEEDED(stmt->ExecuteStep(&hasResult)) && hasResult) {
2754       pageSize = stmt->AsInt32(0);
2755     } else {
2756       MOZ_ASSERT(false, "Couldn't get page_size");
2757       return 0;
2758     }
2759   }
2760   return std::max(0, freeListPagesCount - (mGrowthChunkSize / pageSize));
2761 }
2762
2763 NS_IMETHODIMP
2764 Connection::LoadExtension(const nsACString& aExtensionName,
2765                           mozIStorageCompletionCallback* aCallback) {
2766   AUTO_PROFILER_LABEL("Connection::LoadExtension", OTHER);
2767
2768   // This is a static list of extensions we can load.
2769   // Please use lowercase ASCII names and keep this list alphabetically ordered.
2770   static constexpr nsLiteralCString sSupportedExtensions[] = {
2771       // clang-format off
2772       "fts5"_ns,
2773       // clang-format on
2774   };
2775   if (std::find(std::begin(sSupportedExtensions),
2776                 std::end(sSupportedExtensions),
2777                 aExtensionName) == std::end(sSupportedExtensions)) {
2778     return NS_ERROR_INVALID_ARG;
2779   }
2780
2781   if (!connectionReady()) {
2782     return NS_ERROR_NOT_INITIALIZED;
2783   }
2784
2785   int srv = ::sqlite3_db_config(mDBConn, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,
2786                                 1, nullptr);
2787   if (srv != SQLITE_OK) {
2788     return NS_ERROR_UNEXPECTED;
2789   }
2790
2791   // Track the loaded extension for later connection cloning operations.
2792   {
2793     MutexAutoLock lockedScope(sharedAsyncExecutionMutex);
2794     if (!mLoadedExtensions.EnsureInserted(aExtensionName)) {
2795       // Already loaded, bail out but issue a warning.
2796       NS_WARNING(nsPrintfCString(
2797                      "Tried to register '%s' SQLite extension multiple times!",
2798                      PromiseFlatCString(aExtensionName).get())
2799                      .get());
2800       return NS_OK;
2801     }
2802   }
2803
2804   nsAutoCString entryPoint("sqlite3_");
2805   entryPoint.Append(aExtensionName);
2806   entryPoint.AppendLiteral("_init");
2807
2808   RefPtr<Runnable> loadTask = NS_NewRunnableFunction(
2809       "mozStorageConnection::LoadExtension",
2810       [this, self = RefPtr(this), entryPoint,
2811        callback = RefPtr(aCallback)]() mutable {
2812         MOZ_ASSERT(
2813             !NS_IsMainThread() ||
2814                 (operationSupported(Connection::SYNCHRONOUS) &&
2815                  eventTargetOpenedOn == GetMainThreadSerialEventTarget()),
2816             "Should happen on main-thread only for synchronous connections "
2817             "opened on the main thread");
2818 #ifdef MOZ_FOLD_LIBS
2819         int srv = ::sqlite3_load_extension(mDBConn,
2820                                            MOZ_DLL_PREFIX "nss3" MOZ_DLL_SUFFIX,
2821                                            entryPoint.get(), nullptr);
2822 #else
2823         int srv = ::sqlite3_load_extension(
2824             mDBConn, MOZ_DLL_PREFIX "mozsqlite3" MOZ_DLL_SUFFIX,
2825             entryPoint.get(), nullptr);
2826 #endif
2827         if (!callback) {
2828           return;
2829         };
2830         RefPtr<Runnable> callbackTask = NS_NewRunnableFunction(
2831             "mozStorageConnection::LoadExtension_callback",
2832             [callback = std::move(callback), srv]() {
2833               (void)callback->Complete(convertResultCode(srv), nullptr);
2834             });
2835         if (IsOnCurrentSerialEventTarget(eventTargetOpenedOn)) {
2836           MOZ_ALWAYS_SUCCEEDS(callbackTask->Run());
2837         } else {
2838           // Redispatch the callback to the calling thread.
2839           MOZ_ALWAYS_SUCCEEDS(eventTargetOpenedOn->Dispatch(
2840               callbackTask.forget(), NS_DISPATCH_NORMAL));
2841         }
2842       });
2843
2844   if (NS_IsMainThread() && !operationSupported(Connection::SYNCHRONOUS)) {
2845     // This is a main-thread call to an async-only connection, thus we should
2846     // load the library in the helper thread.
2847     nsIEventTarget* helperThread = getAsyncExecutionTarget();
2848     if (!helperThread) {
2849       return NS_ERROR_NOT_INITIALIZED;
2850     }
2851     MOZ_ALWAYS_SUCCEEDS(
2852         helperThread->Dispatch(loadTask.forget(), NS_DISPATCH_NORMAL));
2853   } else {
2854     // In any other case we just load the extension on the current thread.
2855     MOZ_ALWAYS_SUCCEEDS(loadTask->Run());
2856   }
2857   return NS_OK;
2858 }
2859
2860 NS_IMETHODIMP
2861 Connection::EnableModule(const nsACString& aModuleName) {
2862   if (!connectionReady()) {
2863     return NS_ERROR_NOT_INITIALIZED;
2864   }
2865   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2866   if (NS_FAILED(rv)) {
2867     return rv;
2868   }
2869
2870   for (auto& gModule : gModules) {
2871     struct Module* m = &gModule;
2872     if (aModuleName.Equals(m->name)) {
2873       int srv = m->registerFunc(mDBConn, m->name);
2874       if (srv != SQLITE_OK) return convertResultCode(srv);
2875
2876       return NS_OK;
2877     }
2878   }
2879
2880   return NS_ERROR_FAILURE;
2881 }
2882
2883 NS_IMETHODIMP
2884 Connection::GetQuotaObjects(QuotaObject** aDatabaseQuotaObject,
2885                             QuotaObject** aJournalQuotaObject) {
2886   MOZ_ASSERT(aDatabaseQuotaObject);
2887   MOZ_ASSERT(aJournalQuotaObject);
2888
2889   if (!connectionReady()) {
2890     return NS_ERROR_NOT_INITIALIZED;
2891   }
2892   nsresult rv = ensureOperationSupported(SYNCHRONOUS);
2893   if (NS_FAILED(rv)) {
2894     return rv;
2895   }
2896
2897   sqlite3_file* file;
2898   int srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_FILE_POINTER,
2899                                    &file);
2900   if (srv != SQLITE_OK) {
2901     return convertResultCode(srv);
2902   }
2903
2904   sqlite3_vfs* vfs;
2905   srv =
2906       ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_VFS_POINTER, &vfs);
2907   if (srv != SQLITE_OK) {
2908     return convertResultCode(srv);
2909   }
2910
2911   bool obfusactingVFS = false;
2912
2913   {
2914     const nsDependentCString vfsName{vfs->zName};
2915
2916     if (vfsName == obfsvfs::GetVFSName()) {
2917       obfusactingVFS = true;
2918     } else if (vfsName != quotavfs::GetVFSName()) {
2919       NS_WARNING("Got unexpected vfs");
2920       return NS_ERROR_FAILURE;
2921     }
2922   }
2923
2924   RefPtr<QuotaObject> databaseQuotaObject =
2925       GetQuotaObject(file, obfusactingVFS);
2926   if (NS_WARN_IF(!databaseQuotaObject)) {
2927     return NS_ERROR_FAILURE;
2928   }
2929
2930   srv = ::sqlite3_file_control(mDBConn, nullptr, SQLITE_FCNTL_JOURNAL_POINTER,
2931                                &file);
2932   if (srv != SQLITE_OK) {
2933     return convertResultCode(srv);
2934   }
2935
2936   RefPtr<QuotaObject> journalQuotaObject = GetQuotaObject(file, obfusactingVFS);
2937   if (NS_WARN_IF(!journalQuotaObject)) {
2938     return NS_ERROR_FAILURE;
2939   }
2940
2941   databaseQuotaObject.forget(aDatabaseQuotaObject);
2942   journalQuotaObject.forget(aJournalQuotaObject);
2943   return NS_OK;
2944 }
2945
2946 SQLiteMutex& Connection::GetSharedDBMutex() { return sharedDBMutex; }
2947
2948 uint32_t Connection::GetTransactionNestingLevel(
2949     const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2950   return mTransactionNestingLevel;
2951 }
2952
2953 uint32_t Connection::IncreaseTransactionNestingLevel(
2954     const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2955   return ++mTransactionNestingLevel;
2956 }
2957
2958 uint32_t Connection::DecreaseTransactionNestingLevel(
2959     const mozilla::storage::SQLiteMutexAutoLock& aProofOfLock) {
2960   return --mTransactionNestingLevel;
2961 }
2962
2963 NS_IMETHODIMP
2964 Connection::BackupToFileAsync(nsIFile* aDestinationFile,
2965                               mozIStorageCompletionCallback* aCallback) {
2966   NS_ENSURE_ARG(aDestinationFile);
2967   NS_ENSURE_ARG(aCallback);
2968   NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
2969
2970   // Abort if we're shutting down.
2971   if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
2972     return NS_ERROR_ABORT;
2973   }
2974   // Check if AsyncClose or Close were already invoked.
2975   if (!connectionReady()) {
2976     return NS_ERROR_NOT_INITIALIZED;
2977   }
2978   nsresult rv = ensureOperationSupported(ASYNCHRONOUS);
2979   if (NS_FAILED(rv)) {
2980     return rv;
2981   }
2982   nsIEventTarget* asyncThread = getAsyncExecutionTarget();
2983   if (!asyncThread) {
2984     return NS_ERROR_NOT_INITIALIZED;
2985   }
2986
2987   // Create and dispatch our backup event to the execution thread.
2988   nsCOMPtr<nsIRunnable> backupEvent =
2989       new AsyncBackupDatabaseFile(this, mDBConn, aDestinationFile, aCallback);
2990   rv = asyncThread->Dispatch(backupEvent, NS_DISPATCH_NORMAL);
2991   return rv;
2992 }
2993
2994 }  // namespace mozilla::storage