dom/indexedDB/TransactionThreadPool.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   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 "TransactionThreadPool.h"
   8
   9 #include "nsIObserverService.h"
  10 #include "nsIThreadPool.h"
  11
  12 #include "nsComponentManagerUtils.h"
  13 #include "nsThreadUtils.h"
  14 #include "nsServiceManagerUtils.h"
  15 #include "nsXPCOMCIDInternal.h"
  16
  17 #include "ProfilerHelpers.h"
  18
  19 using mozilla::MonitorAutoLock;
  20
  21 USING_INDEXEDDB_NAMESPACE
  22
  23 namespace {
  24
  25 const uint32_t kThreadLimit = 20;
  26 const uint32_t kIdleThreadLimit = 5;
  27 const uint32_t kIdleThreadTimeoutMs = 30000;
  28
  29 TransactionThreadPool* gThreadPool = nullptr;
  30 bool gShutdown = false;
  31
  32 #ifdef MOZ_ENABLE_PROFILER_SPS
  33
  34 class TransactionThreadPoolListener : public nsIThreadPoolListener
  35 {
  36 public:
  37   NS_DECL_THREADSAFE_ISUPPORTS
  38   NS_DECL_NSITHREADPOOLLISTENER
  39
  40 private:
  41   virtual ~TransactionThreadPoolListener()
  42   { }
  43 };
  44
  45 #endif // MOZ_ENABLE_PROFILER_SPS
  46
  47 } // anonymous namespace
  48
  49 BEGIN_INDEXEDDB_NAMESPACE
  50
  51 class FinishTransactionRunnable MOZ_FINAL : public nsIRunnable
  52 {
  53 public:
  54   NS_DECL_THREADSAFE_ISUPPORTS
  55   NS_DECL_NSIRUNNABLE
  56
  57   inline FinishTransactionRunnable(IDBTransaction* aTransaction,
  58                                    nsCOMPtr<nsIRunnable>& aFinishRunnable);
  59
  60 private:
  61   ~FinishTransactionRunnable() {}
  62
  63   IDBTransaction* mTransaction;
  64   nsCOMPtr<nsIRunnable> mFinishRunnable;
  65 };
  66
  67 END_INDEXEDDB_NAMESPACE
  68
  69 TransactionThreadPool::TransactionThreadPool()
  70 {
  71   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  72   NS_ASSERTION(!gThreadPool, "More than one instance!");
  73 }
  74
  75 TransactionThreadPool::~TransactionThreadPool()
  76 {
  77   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  78   NS_ASSERTION(gThreadPool == this, "Different instances!");
  79   gThreadPool = nullptr;
  80 }
  81
  82 // static
  83 TransactionThreadPool*
  84 TransactionThreadPool::GetOrCreate()
  85 {
  86   if (!gThreadPool && !gShutdown) {
  87     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
  88     nsAutoPtr<TransactionThreadPool> pool(new TransactionThreadPool());
  89
  90     nsresult rv = pool->Init();
  91     NS_ENSURE_SUCCESS(rv, nullptr);
  92
  93     gThreadPool = pool.forget();
  94   }
  95   return gThreadPool;
  96 }
  97
  98 // static
  99 TransactionThreadPool*
 100 TransactionThreadPool::Get()
 101 {
 102   return gThreadPool;
 103 }
 104
 105 // static
 106 void
 107 TransactionThreadPool::Shutdown()
 108 {
 109   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 110
 111   gShutdown = true;
 112
 113   if (gThreadPool) {
 114     if (NS_FAILED(gThreadPool->Cleanup())) {
 115       NS_WARNING("Failed to shutdown thread pool!");
 116     }
 117     delete gThreadPool;
 118     gThreadPool = nullptr;
 119   }
 120 }
 121
 122 nsresult
 123 TransactionThreadPool::Init()
 124 {
 125   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 126
 127   nsresult rv;
 128   mThreadPool = do_CreateInstance(NS_THREADPOOL_CONTRACTID, &rv);
 129   NS_ENSURE_SUCCESS(rv, rv);
 130
 131   rv = mThreadPool->SetName(NS_LITERAL_CSTRING("IndexedDB Trans"));
 132   NS_ENSURE_SUCCESS(rv, rv);
 133
 134   rv = mThreadPool->SetThreadLimit(kThreadLimit);
 135   NS_ENSURE_SUCCESS(rv, rv);
 136
 137   rv = mThreadPool->SetIdleThreadLimit(kIdleThreadLimit);
 138   NS_ENSURE_SUCCESS(rv, rv);
 139
 140   rv = mThreadPool->SetIdleThreadTimeout(kIdleThreadTimeoutMs);
 141   NS_ENSURE_SUCCESS(rv, rv);
 142
 143 #ifdef MOZ_ENABLE_PROFILER_SPS
 144   nsCOMPtr<nsIThreadPoolListener> listener =
 145     new TransactionThreadPoolListener();
 146
 147   rv = mThreadPool->SetListener(listener);
 148   NS_ENSURE_SUCCESS(rv, rv);
 149 #endif
 150
 151   return NS_OK;
 152 }
 153
 154 nsresult
 155 TransactionThreadPool::Cleanup()
 156 {
 157   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 158
 159   PROFILER_MAIN_THREAD_LABEL("TransactionThreadPool", "Cleanup",
 160     js::ProfileEntry::Category::STORAGE);
 161
 162   nsresult rv = mThreadPool->Shutdown();
 163   NS_ENSURE_SUCCESS(rv, rv);
 164
 165   // Make sure the pool is still accessible while any callbacks generated from
 166   // the other threads are processed.
 167   rv = NS_ProcessPendingEvents(nullptr);
 168   NS_ENSURE_SUCCESS(rv, rv);
 169
 170   if (!mCompleteCallbacks.IsEmpty()) {
 171     // Run all callbacks manually now.
 172     for (uint32_t index = 0; index < mCompleteCallbacks.Length(); index++) {
 173       mCompleteCallbacks[index].mCallback->Run();
 174     }
 175     mCompleteCallbacks.Clear();
 176
 177     // And make sure they get processed.
 178     rv = NS_ProcessPendingEvents(nullptr);
 179     NS_ENSURE_SUCCESS(rv, rv);
 180   }
 181
 182   return NS_OK;
 183 }
 184
 185 // static
 186 PLDHashOperator
 187 TransactionThreadPool::MaybeUnblockTransaction(nsPtrHashKey<TransactionInfo>* aKey,
 188                                                void* aUserArg)
 189 {
 190   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 191
 192   TransactionInfo* maybeUnblockedInfo = aKey->GetKey();
 193   TransactionInfo* finishedInfo = static_cast<TransactionInfo*>(aUserArg);
 194
 195   NS_ASSERTION(maybeUnblockedInfo->blockedOn.Contains(finishedInfo),
 196                "Huh?");
 197   maybeUnblockedInfo->blockedOn.RemoveEntry(finishedInfo);
 198   if (!maybeUnblockedInfo->blockedOn.Count()) {
 199     // Let this transaction run.
 200     maybeUnblockedInfo->queue->Unblock();
 201   }
 202
 203   return PL_DHASH_NEXT;
 204 }
 205
 206 void
 207 TransactionThreadPool::FinishTransaction(IDBTransaction* aTransaction)
 208 {
 209   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 210   NS_ASSERTION(aTransaction, "Null pointer!");
 211
 212   PROFILER_MAIN_THREAD_LABEL("TransactionThreadPool", "FinishTransaction",
 213     js::ProfileEntry::Category::STORAGE);
 214
 215   // AddRef here because removing from the hash will call Release.
 216   nsRefPtr<IDBTransaction> transaction(aTransaction);
 217
 218   const nsACString& databaseId = aTransaction->mDatabase->Id();
 219
 220   DatabaseTransactionInfo* dbTransactionInfo;
 221   if (!mTransactionsInProgress.Get(databaseId, &dbTransactionInfo)) {
 222     NS_ERROR("We don't know anyting about this database?!");
 223     return;
 224   }
 225
 226   DatabaseTransactionInfo::TransactionHashtable& transactionsInProgress =
 227     dbTransactionInfo->transactions;
 228
 229   uint32_t transactionCount = transactionsInProgress.Count();
 230
 231 #ifdef DEBUG
 232   if (aTransaction->mMode == IDBTransaction::VERSION_CHANGE) {
 233     NS_ASSERTION(transactionCount == 1,
 234                  "More transactions running than should be!");
 235   }
 236 #endif
 237
 238   if (transactionCount == 1) {
 239 #ifdef DEBUG
 240     {
 241       const TransactionInfo* info = transactionsInProgress.Get(aTransaction);
 242       NS_ASSERTION(info->transaction == aTransaction, "Transaction mismatch!");
 243     }
 244 #endif
 245     mTransactionsInProgress.Remove(databaseId);
 246
 247     // See if we need to fire any complete callbacks.
 248     uint32_t index = 0;
 249     while (index < mCompleteCallbacks.Length()) {
 250       if (MaybeFireCallback(mCompleteCallbacks[index])) {
 251         mCompleteCallbacks.RemoveElementAt(index);
 252       }
 253       else {
 254         index++;
 255       }
 256     }
 257
 258     return;
 259   }
 260   TransactionInfo* info = transactionsInProgress.Get(aTransaction);
 261   NS_ASSERTION(info, "We've never heard of this transaction?!?");
 262
 263   const nsTArray<nsString>& objectStoreNames = aTransaction->mObjectStoreNames;
 264   for (size_t index = 0, count = objectStoreNames.Length(); index < count;
 265        index++) {
 266     TransactionInfoPair* blockInfo =
 267       dbTransactionInfo->blockingTransactions.Get(objectStoreNames[index]);
 268     NS_ASSERTION(blockInfo, "Huh?");
 269
 270     if (aTransaction->mMode == IDBTransaction::READ_WRITE &&
 271         blockInfo->lastBlockingReads == info) {
 272       blockInfo->lastBlockingReads = nullptr;
 273     }
 274
 275     size_t i = blockInfo->lastBlockingWrites.IndexOf(info);
 276     if (i != blockInfo->lastBlockingWrites.NoIndex) {
 277       blockInfo->lastBlockingWrites.RemoveElementAt(i);
 278     }
 279   }
 280
 281   info->blocking.EnumerateEntries(MaybeUnblockTransaction, info);
 282
 283   transactionsInProgress.Remove(aTransaction);
 284 }
 285
 286 TransactionThreadPool::TransactionQueue&
 287 TransactionThreadPool::GetQueueForTransaction(IDBTransaction* aTransaction)
 288 {
 289   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 290   NS_ASSERTION(aTransaction, "Null pointer!");
 291
 292   const nsACString& databaseId = aTransaction->mDatabase->Id();
 293
 294   const nsTArray<nsString>& objectStoreNames = aTransaction->mObjectStoreNames;
 295   const uint16_t mode = aTransaction->mMode;
 296
 297   // See if we can run this transaction now.
 298   DatabaseTransactionInfo* dbTransactionInfo;
 299   if (!mTransactionsInProgress.Get(databaseId, &dbTransactionInfo)) {
 300     // First transaction for this database.
 301     dbTransactionInfo = new DatabaseTransactionInfo();
 302     mTransactionsInProgress.Put(databaseId, dbTransactionInfo);
 303   }
 304
 305   DatabaseTransactionInfo::TransactionHashtable& transactionsInProgress =
 306     dbTransactionInfo->transactions;
 307   TransactionInfo* info = transactionsInProgress.Get(aTransaction);
 308   if (info) {
 309     // We recognize this one.
 310     return *info->queue;
 311   }
 312
 313   TransactionInfo* transactionInfo = new TransactionInfo(aTransaction);
 314
 315   dbTransactionInfo->transactions.Put(aTransaction, transactionInfo);;
 316
 317   for (uint32_t index = 0, count = objectStoreNames.Length(); index < count;
 318        index++) {
 319     TransactionInfoPair* blockInfo =
 320       dbTransactionInfo->blockingTransactions.Get(objectStoreNames[index]);
 321     if (!blockInfo) {
 322       blockInfo = new TransactionInfoPair();
 323       blockInfo->lastBlockingReads = nullptr;
 324       dbTransactionInfo->blockingTransactions.Put(objectStoreNames[index],
 325                                                   blockInfo);
 326     }
 327
 328     // Mark what we are blocking on.
 329     if (blockInfo->lastBlockingReads) {
 330       TransactionInfo* blockingInfo = blockInfo->lastBlockingReads;
 331       transactionInfo->blockedOn.PutEntry(blockingInfo);
 332       blockingInfo->blocking.PutEntry(transactionInfo);
 333     }
 334
 335     if (mode == IDBTransaction::READ_WRITE &&
 336         blockInfo->lastBlockingWrites.Length()) {
 337       for (uint32_t index = 0,
 338            count = blockInfo->lastBlockingWrites.Length(); index < count;
 339            index++) {
 340         TransactionInfo* blockingInfo = blockInfo->lastBlockingWrites[index];
 341         transactionInfo->blockedOn.PutEntry(blockingInfo);
 342         blockingInfo->blocking.PutEntry(transactionInfo);
 343       }
 344     }
 345
 346     if (mode == IDBTransaction::READ_WRITE) {
 347       blockInfo->lastBlockingReads = transactionInfo;
 348       blockInfo->lastBlockingWrites.Clear();
 349     }
 350     else {
 351       blockInfo->lastBlockingWrites.AppendElement(transactionInfo);
 352     }
 353   }
 354
 355   if (!transactionInfo->blockedOn.Count()) {
 356     transactionInfo->queue->Unblock();
 357   }
 358
 359   return *transactionInfo->queue;
 360 }
 361
 362 nsresult
 363 TransactionThreadPool::Dispatch(IDBTransaction* aTransaction,
 364                                 nsIRunnable* aRunnable,
 365                                 bool aFinish,
 366                                 nsIRunnable* aFinishRunnable)
 367 {
 368   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 369   NS_ASSERTION(aTransaction, "Null pointer!");
 370   NS_ASSERTION(aRunnable, "Null pointer!");
 371
 372   if (aTransaction->mDatabase->IsInvalidated() && !aFinish) {
 373     return NS_ERROR_NOT_AVAILABLE;
 374   }
 375
 376   TransactionQueue& queue = GetQueueForTransaction(aTransaction);
 377
 378   queue.Dispatch(aRunnable);
 379   if (aFinish) {
 380     queue.Finish(aFinishRunnable);
 381   }
 382   return NS_OK;
 383 }
 384
 385 void
 386 TransactionThreadPool::WaitForDatabasesToComplete(
 387                                    nsTArray<nsRefPtr<IDBDatabase> >& aDatabases,
 388                                    nsIRunnable* aCallback)
 389 {
 390   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 391   NS_ASSERTION(!aDatabases.IsEmpty(), "No databases to wait on!");
 392   NS_ASSERTION(aCallback, "Null pointer!");
 393
 394   DatabasesCompleteCallback* callback = mCompleteCallbacks.AppendElement();
 395
 396   callback->mCallback = aCallback;
 397   callback->mDatabases.SwapElements(aDatabases);
 398
 399   if (MaybeFireCallback(*callback)) {
 400     mCompleteCallbacks.RemoveElementAt(mCompleteCallbacks.Length() - 1);
 401   }
 402 }
 403
 404 // static
 405 PLDHashOperator
 406 TransactionThreadPool::CollectTransactions(IDBTransaction* aKey,
 407                                            TransactionInfo* aValue,
 408                                            void* aUserArg)
 409 {
 410   nsAutoTArray<nsRefPtr<IDBTransaction>, 50>* transactionArray =
 411     static_cast<nsAutoTArray<nsRefPtr<IDBTransaction>, 50>*>(aUserArg);
 412   transactionArray->AppendElement(aKey);
 413
 414   return PL_DHASH_NEXT;
 415 }
 416
 417 void
 418 TransactionThreadPool::AbortTransactionsForDatabase(IDBDatabase* aDatabase)
 419 {
 420   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 421   NS_ASSERTION(aDatabase, "Null pointer!");
 422
 423   PROFILER_MAIN_THREAD_LABEL("TransactionThreadPool", "AbortTransactionsForDatabase",
 424     js::ProfileEntry::Category::STORAGE);
 425
 426   // Get list of transactions for this database id
 427   DatabaseTransactionInfo* dbTransactionInfo;
 428   if (!mTransactionsInProgress.Get(aDatabase->Id(), &dbTransactionInfo)) {
 429     // If there are no transactions, we're done.
 430     return;
 431   }
 432
 433   // Collect any running transactions
 434   DatabaseTransactionInfo::TransactionHashtable& transactionsInProgress =
 435     dbTransactionInfo->transactions;
 436
 437   NS_ASSERTION(transactionsInProgress.Count(), "Should never be 0!");
 438
 439   nsAutoTArray<nsRefPtr<IDBTransaction>, 50> transactions;
 440   transactionsInProgress.EnumerateRead(CollectTransactions, &transactions);
 441
 442   // Abort transactions. Do this after collecting the transactions in case
 443   // calling Abort() modifies the data structures we're iterating above.
 444   for (uint32_t index = 0; index < transactions.Length(); index++) {
 445     if (transactions[index]->Database() != aDatabase) {
 446       continue;
 447     }
 448
 449     // This can fail, for example if the transaction is in the process of
 450     // being comitted. That is expected and fine, so we ignore any returned
 451     // errors.
 452     ErrorResult rv;
 453     transactions[index]->Abort(rv);
 454   }
 455 }
 456
 457 struct MOZ_STACK_CLASS TransactionSearchInfo
 458 {
 459   TransactionSearchInfo(nsIOfflineStorage* aDatabase)
 460     : db(aDatabase), found(false)
 461   {
 462   }
 463
 464   nsIOfflineStorage* db;
 465   bool found;
 466 };
 467
 468 // static
 469 PLDHashOperator
 470 TransactionThreadPool::FindTransaction(IDBTransaction* aKey,
 471                                        TransactionInfo* aValue,
 472                                        void* aUserArg)
 473 {
 474   TransactionSearchInfo* info = static_cast<TransactionSearchInfo*>(aUserArg);
 475
 476   if (aKey->Database() == info->db) {
 477     info->found = true;
 478     return PL_DHASH_STOP;
 479   }
 480
 481   return PL_DHASH_NEXT;
 482 }
 483 bool
 484 TransactionThreadPool::HasTransactionsForDatabase(IDBDatabase* aDatabase)
 485 {
 486   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 487   NS_ASSERTION(aDatabase, "Null pointer!");
 488
 489   DatabaseTransactionInfo* dbTransactionInfo = nullptr;
 490   dbTransactionInfo = mTransactionsInProgress.Get(aDatabase->Id());
 491   if (!dbTransactionInfo) {
 492     return false;
 493   }
 494
 495   TransactionSearchInfo info(aDatabase);
 496   dbTransactionInfo->transactions.EnumerateRead(FindTransaction, &info);
 497
 498   return info.found;
 499 }
 500
 501 bool
 502 TransactionThreadPool::MaybeFireCallback(DatabasesCompleteCallback aCallback)
 503 {
 504   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 505
 506   PROFILER_MAIN_THREAD_LABEL("TransactionThreadPool", "MaybeFireCallback",
 507     js::ProfileEntry::Category::STORAGE);
 508
 509   for (uint32_t index = 0; index < aCallback.mDatabases.Length(); index++) {
 510     IDBDatabase* database = aCallback.mDatabases[index];
 511     if (!database) {
 512       MOZ_CRASH();
 513     }
 514
 515     if (mTransactionsInProgress.Get(database->Id(), nullptr)) {
 516       return false;
 517     }
 518   }
 519
 520   aCallback.mCallback->Run();
 521   return true;
 522 }
 523
 524 TransactionThreadPool::
 525 TransactionQueue::TransactionQueue(IDBTransaction* aTransaction)
 526 : mMonitor("TransactionQueue::mMonitor"),
 527   mTransaction(aTransaction),
 528   mShouldFinish(false)
 529 {
 530   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 531   NS_ASSERTION(aTransaction, "Null pointer!");
 532 }
 533
 534 void
 535 TransactionThreadPool::TransactionQueue::Unblock()
 536 {
 537   MonitorAutoLock lock(mMonitor);
 538
 539   // NB: Finish may be called before Unblock.
 540
 541   TransactionThreadPool::Get()->mThreadPool->
 542     Dispatch(this, NS_DISPATCH_NORMAL);
 543 }
 544
 545 void
 546 TransactionThreadPool::TransactionQueue::Dispatch(nsIRunnable* aRunnable)
 547 {
 548   MonitorAutoLock lock(mMonitor);
 549
 550   NS_ASSERTION(!mShouldFinish, "Dispatch called after Finish!");
 551
 552   mQueue.AppendElement(aRunnable);
 553
 554   mMonitor.Notify();
 555 }
 556
 557 void
 558 TransactionThreadPool::TransactionQueue::Finish(nsIRunnable* aFinishRunnable)
 559 {
 560   MonitorAutoLock lock(mMonitor);
 561
 562   NS_ASSERTION(!mShouldFinish, "Finish called more than once!");
 563
 564   mShouldFinish = true;
 565   mFinishRunnable = aFinishRunnable;
 566
 567   mMonitor.Notify();
 568 }
 569
 570 NS_IMPL_ISUPPORTS(TransactionThreadPool::TransactionQueue, nsIRunnable)
 571
 572 NS_IMETHODIMP
 573 TransactionThreadPool::TransactionQueue::Run()
 574 {
 575   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
 576   NS_ASSERTION(IndexedDatabaseManager::IsMainProcess(), "Wrong process!");
 577
 578   PROFILER_LABEL("TransactionQueue", "Run",
 579     js::ProfileEntry::Category::STORAGE);
 580
 581   IDB_PROFILER_MARK("IndexedDB Transaction %llu: Beginning database work",
 582                     "IDBTransaction[%llu] DT Start",
 583                     mTransaction->GetSerialNumber());
 584
 585   nsAutoTArray<nsCOMPtr<nsIRunnable>, 10> queue;
 586   nsCOMPtr<nsIRunnable> finishRunnable;
 587   bool shouldFinish = false;
 588
 589   do {
 590     NS_ASSERTION(queue.IsEmpty(), "Should have cleared this!");
 591
 592     {
 593       MonitorAutoLock lock(mMonitor);
 594       while (!mShouldFinish && mQueue.IsEmpty()) {
 595         if (NS_FAILED(mMonitor.Wait())) {
 596           NS_ERROR("Failed to wait!");
 597         }
 598       }
 599
 600       mQueue.SwapElements(queue);
 601       if (mShouldFinish) {
 602         mFinishRunnable.swap(finishRunnable);
 603         shouldFinish = true;
 604       }
 605     }
 606
 607     uint32_t count = queue.Length();
 608     for (uint32_t index = 0; index < count; index++) {
 609       nsCOMPtr<nsIRunnable>& runnable = queue[index];
 610       runnable->Run();
 611       runnable = nullptr;
 612     }
 613
 614     if (count) {
 615       queue.Clear();
 616     }
 617   } while (!shouldFinish);
 618
 619   IDB_PROFILER_MARK("IndexedDB Transaction %llu: Finished database work",
 620                     "IDBTransaction[%llu] DT Done",
 621                     mTransaction->GetSerialNumber());
 622
 623   nsCOMPtr<nsIRunnable> finishTransactionRunnable =
 624     new FinishTransactionRunnable(mTransaction, finishRunnable);
 625   if (NS_FAILED(NS_DispatchToMainThread(finishTransactionRunnable))) {
 626     NS_WARNING("Failed to dispatch finishTransactionRunnable!");
 627   }
 628
 629   return NS_OK;
 630 }
 631
 632 FinishTransactionRunnable::FinishTransactionRunnable(
 633                                          IDBTransaction* aTransaction,
 634                                          nsCOMPtr<nsIRunnable>& aFinishRunnable)
 635 : mTransaction(aTransaction)
 636 {
 637   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
 638   NS_ASSERTION(aTransaction, "Null pointer!");
 639   mFinishRunnable.swap(aFinishRunnable);
 640 }
 641
 642 NS_IMPL_ISUPPORTS(FinishTransactionRunnable, nsIRunnable)
 643
 644 NS_IMETHODIMP
 645 FinishTransactionRunnable::Run()
 646 {
 647   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 648
 649   PROFILER_MAIN_THREAD_LABEL("FinishTransactionRunnable", "Run",
 650     js::ProfileEntry::Category::STORAGE);
 651
 652   if (!gThreadPool) {
 653     NS_ERROR("Running after shutdown!");
 654     return NS_ERROR_FAILURE;
 655   }
 656
 657   gThreadPool->FinishTransaction(mTransaction);
 658
 659   if (mFinishRunnable) {
 660     mFinishRunnable->Run();
 661     mFinishRunnable = nullptr;
 662   }
 663
 664   return NS_OK;
 665 }
 666
 667 #ifdef MOZ_ENABLE_PROFILER_SPS
 668
 669 NS_IMPL_ISUPPORTS(TransactionThreadPoolListener, nsIThreadPoolListener)
 670
 671 NS_IMETHODIMP
 672 TransactionThreadPoolListener::OnThreadCreated()
 673 {
 674   MOZ_ASSERT(!NS_IsMainThread());
 675   char aLocal;
 676   profiler_register_thread("IndexedDB Transaction", &aLocal);
 677   return NS_OK;
 678 }
 679
 680 NS_IMETHODIMP
 681 TransactionThreadPoolListener::OnThreadShuttingDown()
 682 {
 683   MOZ_ASSERT(!NS_IsMainThread());
 684   profiler_unregister_thread();
 685   return NS_OK;
 686 }
 687
 688 #endif // MOZ_ENABLE_PROFILER_SPS