dom/simpledb/ActorsParent.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "ActorsParent.h"
   8
   9 // Local includes
  10 #include "SimpleDBCommon.h"
  11
  12 // Global includes
  13 #include <cstdint>
  14 #include <cstdlib>
  15 #include <new>
  16 #include <utility>
  17 #include "ErrorList.h"
  18 #include "MainThreadUtils.h"
  19 #include "mozilla/AlreadyAddRefed.h"
  20 #include "mozilla/Assertions.h"
  21 #include "mozilla/Atomics.h"
  22 #include "mozilla/DebugOnly.h"
  23 #include "mozilla/FixedBufferOutputStream.h"
  24 #include "mozilla/Maybe.h"
  25 #include "mozilla/Preferences.h"
  26 #include "mozilla/RefPtr.h"
  27 #include "mozilla/Result.h"
  28 #include "mozilla/ResultExtensions.h"
  29 #include "mozilla/SpinEventLoopUntil.h"
  30 #include "mozilla/StaticPtr.h"
  31 #include "mozilla/Unused.h"
  32 #include "mozilla/Variant.h"
  33 #include "mozilla/dom/PBackgroundSDBConnection.h"
  34 #include "mozilla/dom/PBackgroundSDBConnectionParent.h"
  35 #include "mozilla/dom/PBackgroundSDBRequestParent.h"
  36 #include "mozilla/dom/ipc/IdType.h"
  37 #include "mozilla/dom/quota/Client.h"
  38 #include "mozilla/dom/quota/ClientImpl.h"
  39 #include "mozilla/dom/quota/DirectoryLock.h"
  40 #include "mozilla/dom/quota/FileStreams.h"
  41 #include "mozilla/dom/quota/QuotaCommon.h"
  42 #include "mozilla/dom/quota/QuotaManager.h"
  43 #include "mozilla/dom/quota/ResultExtensions.h"
  44 #include "mozilla/dom/quota/UsageInfo.h"
  45 #include "mozilla/ipc/BackgroundParent.h"
  46 #include "mozilla/ipc/BackgroundUtils.h"
  47 #include "mozilla/ipc/PBackgroundParent.h"
  48 #include "mozilla/ipc/PBackgroundSharedTypes.h"
  49 #include "mozilla/ipc/ProtocolUtils.h"
  50 #include "nsCOMPtr.h"
  51 #include "nsDebug.h"
  52 #include "nsError.h"
  53 #include "nsIDirectoryEnumerator.h"
  54 #include "nsIEventTarget.h"
  55 #include "nsIFile.h"
  56 #include "nsIFileStreams.h"
  57 #include "nsIInputStream.h"
  58 #include "nsIOutputStream.h"
  59 #include "nsIRunnable.h"
  60 #include "nsISeekableStream.h"
  61 #include "nsISupports.h"
  62 #include "nsIThread.h"
  63 #include "nsLiteralString.h"
  64 #include "nsString.h"
  65 #include "nsStringFwd.h"
  66 #include "nsStringStream.h"
  67 #include "nsTArray.h"
  68 #include "nsTLiteralString.h"
  69 #include "nsTStringRepr.h"
  70 #include "nsThreadUtils.h"
  71 #include "nscore.h"
  72 #include "prio.h"
  73
  74 namespace mozilla::dom {
  75
  76 using namespace mozilla::dom::quota;
  77 using namespace mozilla::ipc;
  78
  79 namespace {
  80
  81 /*******************************************************************************
  82  * Constants
  83  ******************************************************************************/
  84
  85 const uint32_t kCopyBufferSize = 32768;
  86
  87 constexpr auto kSDBSuffix = u".sdb"_ns;
  88
  89 /*******************************************************************************
  90  * Actor class declarations
  91  ******************************************************************************/
  92
  93 class StreamHelper final : public Runnable {
  94   nsCOMPtr<nsIEventTarget> mOwningEventTarget;
  95   nsCOMPtr<nsIFileRandomAccessStream> mFileRandomAccessStream;
  96   nsCOMPtr<nsIRunnable> mCallback;
  97
  98  public:
  99   StreamHelper(nsIFileRandomAccessStream* aFileRandomAccessStream,
 100                nsIRunnable* aCallback);
 101
 102   void AsyncClose();
 103
 104  private:
 105   ~StreamHelper() override;
 106
 107   void RunOnBackgroundThread();
 108
 109   void RunOnIOThread();
 110
 111   NS_DECL_NSIRUNNABLE
 112 };
 113
 114 class Connection final : public PBackgroundSDBConnectionParent {
 115   RefPtr<DirectoryLock> mDirectoryLock;
 116   nsCOMPtr<nsIFileRandomAccessStream> mFileRandomAccessStream;
 117   const PrincipalInfo mPrincipalInfo;
 118   nsCString mOrigin;
 119   nsString mName;
 120
 121   PersistenceType mPersistenceType;
 122   bool mRunningRequest;
 123   bool mOpen;
 124   bool mAllowedToClose;
 125   bool mActorDestroyed;
 126
 127  public:
 128   Connection(PersistenceType aPersistenceType,
 129              const PrincipalInfo& aPrincipalInfo);
 130
 131   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(mozilla::dom::Connection)
 132
 133   Maybe<DirectoryLock&> MaybeDirectoryLockRef() const {
 134     AssertIsOnBackgroundThread();
 135
 136     return ToMaybeRef(mDirectoryLock.get());
 137   }
 138
 139   nsIFileRandomAccessStream* GetFileRandomAccessStream() const {
 140     AssertIsOnIOThread();
 141
 142     return mFileRandomAccessStream;
 143   }
 144
 145   PersistenceType GetPersistenceType() const { return mPersistenceType; }
 146
 147   const PrincipalInfo& GetPrincipalInfo() const {
 148     AssertIsOnBackgroundThread();
 149
 150     return mPrincipalInfo;
 151   }
 152
 153   const nsCString& Origin() const {
 154     AssertIsOnBackgroundThread();
 155     MOZ_ASSERT(!mOrigin.IsEmpty());
 156
 157     return mOrigin;
 158   }
 159
 160   const nsString& Name() const {
 161     AssertIsOnBackgroundThread();
 162     MOZ_ASSERT(!mName.IsEmpty());
 163
 164     return mName;
 165   }
 166
 167   void OnNewRequest();
 168
 169   void OnRequestFinished();
 170
 171   void OnOpen(
 172       const nsACString& aOrigin, const nsAString& aName,
 173       already_AddRefed<DirectoryLock> aDirectoryLock,
 174       already_AddRefed<nsIFileRandomAccessStream> aFileRandomAccessStream);
 175
 176   void OnClose();
 177
 178   void AllowToClose();
 179
 180  private:
 181   ~Connection();
 182
 183   void MaybeCloseStream();
 184
 185   bool VerifyRequestParams(const SDBRequestParams& aParams) const;
 186
 187   // IPDL methods.
 188   virtual void ActorDestroy(ActorDestroyReason aWhy) override;
 189
 190   mozilla::ipc::IPCResult RecvDeleteMe() override;
 191
 192   virtual PBackgroundSDBRequestParent* AllocPBackgroundSDBRequestParent(
 193       const SDBRequestParams& aParams) override;
 194
 195   virtual mozilla::ipc::IPCResult RecvPBackgroundSDBRequestConstructor(
 196       PBackgroundSDBRequestParent* aActor,
 197       const SDBRequestParams& aParams) override;
 198
 199   virtual bool DeallocPBackgroundSDBRequestParent(
 200       PBackgroundSDBRequestParent* aActor) override;
 201 };
 202
 203 class ConnectionOperationBase : public Runnable,
 204                                 public PBackgroundSDBRequestParent {
 205   nsCOMPtr<nsIEventTarget> mOwningEventTarget;
 206   RefPtr<Connection> mConnection;
 207   nsresult mResultCode;
 208   Atomic<bool> mOperationMayProceed;
 209   bool mActorDestroyed;
 210
 211  public:
 212   nsIEventTarget* OwningEventTarget() const {
 213     MOZ_ASSERT(mOwningEventTarget);
 214
 215     return mOwningEventTarget;
 216   }
 217
 218   bool IsOnOwningThread() const {
 219     MOZ_ASSERT(mOwningEventTarget);
 220
 221     bool current;
 222     return NS_SUCCEEDED(mOwningEventTarget->IsOnCurrentThread(&current)) &&
 223            current;
 224   }
 225
 226   void AssertIsOnOwningThread() const {
 227     MOZ_ASSERT(IsOnBackgroundThread());
 228     MOZ_ASSERT(IsOnOwningThread());
 229   }
 230
 231   Connection* GetConnection() const {
 232     MOZ_ASSERT(mConnection);
 233
 234     return mConnection;
 235   }
 236
 237   nsresult ResultCode() const { return mResultCode; }
 238
 239   void MaybeSetFailureCode(nsresult aErrorCode) {
 240     MOZ_ASSERT(NS_FAILED(aErrorCode));
 241
 242     if (NS_SUCCEEDED(mResultCode)) {
 243       mResultCode = aErrorCode;
 244     }
 245   }
 246
 247   // May be called on any thread, but you should call IsActorDestroyed() if
 248   // you know you're on the background thread because it is slightly faster.
 249   bool OperationMayProceed() const { return mOperationMayProceed; }
 250
 251   bool IsActorDestroyed() const {
 252     AssertIsOnOwningThread();
 253
 254     return mActorDestroyed;
 255   }
 256
 257   // May be overridden by subclasses if they need to perform work on the
 258   // background thread before being dispatched but must always call the base
 259   // class implementation. Returning false will kill the child actors and
 260   // prevent dispatch.
 261   virtual bool Init();
 262
 263   virtual nsresult Dispatch();
 264
 265   // This callback will be called on the background thread before releasing the
 266   // final reference to this request object. Subclasses may perform any
 267   // additional cleanup here but must always call the base class implementation.
 268   virtual void Cleanup();
 269
 270  protected:
 271   ConnectionOperationBase(Connection* aConnection)
 272       : Runnable("dom::ConnectionOperationBase"),
 273         mOwningEventTarget(GetCurrentSerialEventTarget()),
 274         mConnection(aConnection),
 275         mResultCode(NS_OK),
 276         mOperationMayProceed(true),
 277         mActorDestroyed(false) {
 278     AssertIsOnOwningThread();
 279   }
 280
 281   ~ConnectionOperationBase() override;
 282
 283   void SendResults();
 284
 285   void DatabaseWork();
 286
 287   // Methods that subclasses must implement.
 288   virtual nsresult DoDatabaseWork(
 289       nsIFileRandomAccessStream* aFileRandomAccessStream) = 0;
 290
 291   // Subclasses use this override to set the IPDL response value.
 292   virtual void GetResponse(SDBRequestResponse& aResponse) = 0;
 293
 294   // A method that subclasses may implement.
 295   virtual void OnSuccess();
 296
 297  private:
 298   NS_IMETHOD
 299   Run() override;
 300
 301   // IPDL methods.
 302   void ActorDestroy(ActorDestroyReason aWhy) override;
 303 };
 304
 305 class OpenOp final : public ConnectionOperationBase,
 306                      public OpenDirectoryListener {
 307   enum class State {
 308     // Just created on the PBackground thread, dispatched to the main thread.
 309     // Next step is FinishOpen.
 310     Initial,
 311
 312     // Ensuring quota manager is created and opening directory on the
 313     // PBackground thread. Next step is either SendingResults if quota manager
 314     // is not available or DirectoryOpenPending if quota manager is available.
 315     FinishOpen,
 316
 317     // Waiting for directory open allowed on the PBackground thread. The next
 318     // step is either SendingResults if directory lock failed to acquire, or
 319     // DatabaseWorkOpen if directory lock is acquired.
 320     DirectoryOpenPending,
 321
 322     // Waiting to do/doing work on the QuotaManager IO thread. Its next step is
 323     // SendingResults.
 324     DatabaseWorkOpen,
 325
 326     // Waiting to send/sending results on the PBackground thread. Next step is
 327     // Completed.
 328     SendingResults,
 329
 330     // All done.
 331     Completed
 332   };
 333
 334   const SDBRequestOpenParams mParams;
 335   RefPtr<DirectoryLock> mDirectoryLock;
 336   nsCOMPtr<nsIFileRandomAccessStream> mFileRandomAccessStream;
 337   // XXX Consider changing this to ClientMetadata.
 338   quota::OriginMetadata mOriginMetadata;
 339   State mState;
 340   bool mFileRandomAccessStreamOpen;
 341
 342  public:
 343   OpenOp(Connection* aConnection, const SDBRequestParams& aParams);
 344
 345   nsresult Dispatch() override;
 346
 347  private:
 348   ~OpenOp() override;
 349
 350   nsresult Open();
 351
 352   nsresult FinishOpen();
 353
 354   nsresult SendToIOThread();
 355
 356   nsresult DatabaseWork();
 357
 358   void StreamClosedCallback();
 359
 360   // ConnectionOperationBase overrides
 361   nsresult DoDatabaseWork(
 362       nsIFileRandomAccessStream* aFileRandomAccessStream) override;
 363
 364   void GetResponse(SDBRequestResponse& aResponse) override;
 365
 366   void OnSuccess() override;
 367
 368   void Cleanup() override;
 369
 370   NS_DECL_ISUPPORTS_INHERITED
 371
 372   NS_IMETHOD
 373   Run() override;
 374
 375   // OpenDirectoryListener overrides.
 376   void DirectoryLockAcquired(DirectoryLock* aLock) override;
 377
 378   void DirectoryLockFailed() override;
 379 };
 380
 381 class SeekOp final : public ConnectionOperationBase {
 382   const SDBRequestSeekParams mParams;
 383
 384  public:
 385   SeekOp(Connection* aConnection, const SDBRequestParams& aParams);
 386
 387  private:
 388   ~SeekOp() override = default;
 389
 390   nsresult DoDatabaseWork(
 391       nsIFileRandomAccessStream* aFileRandomAccessStream) override;
 392
 393   void GetResponse(SDBRequestResponse& aResponse) override;
 394 };
 395
 396 class ReadOp final : public ConnectionOperationBase {
 397   const SDBRequestReadParams mParams;
 398
 399   RefPtr<FixedBufferOutputStream> mOutputStream;
 400
 401  public:
 402   ReadOp(Connection* aConnection, const SDBRequestParams& aParams);
 403
 404   bool Init() override;
 405
 406  private:
 407   ~ReadOp() override = default;
 408
 409   nsresult DoDatabaseWork(
 410       nsIFileRandomAccessStream* aFileRandomAccessStream) override;
 411
 412   void GetResponse(SDBRequestResponse& aResponse) override;
 413 };
 414
 415 class WriteOp final : public ConnectionOperationBase {
 416   const SDBRequestWriteParams mParams;
 417
 418   nsCOMPtr<nsIInputStream> mInputStream;
 419
 420   uint64_t mSize;
 421
 422  public:
 423   WriteOp(Connection* aConnection, const SDBRequestParams& aParams);
 424
 425   bool Init() override;
 426
 427  private:
 428   ~WriteOp() override = default;
 429
 430   nsresult DoDatabaseWork(
 431       nsIFileRandomAccessStream* aFileRandomAccessStream) override;
 432
 433   void GetResponse(SDBRequestResponse& aResponse) override;
 434 };
 435
 436 class CloseOp final : public ConnectionOperationBase {
 437  public:
 438   explicit CloseOp(Connection* aConnection);
 439
 440  private:
 441   ~CloseOp() override = default;
 442
 443   nsresult DoDatabaseWork(
 444       nsIFileRandomAccessStream* aFileRandomAccessStream) override;
 445
 446   void GetResponse(SDBRequestResponse& aResponse) override;
 447
 448   void OnSuccess() override;
 449 };
 450
 451 /*******************************************************************************
 452  * Other class declarations
 453  ******************************************************************************/
 454
 455 class QuotaClient final : public mozilla::dom::quota::Client {
 456   static QuotaClient* sInstance;
 457
 458  public:
 459   QuotaClient();
 460
 461   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(QuotaClient, override)
 462
 463   Type GetType() override;
 464
 465   Result<UsageInfo, nsresult> InitOrigin(PersistenceType aPersistenceType,
 466                                          const OriginMetadata& aOriginMetadata,
 467                                          const AtomicBool& aCanceled) override;
 468
 469   nsresult InitOriginWithoutTracking(PersistenceType aPersistenceType,
 470                                      const OriginMetadata& aOriginMetadata,
 471                                      const AtomicBool& aCanceled) override;
 472
 473   Result<UsageInfo, nsresult> GetUsageForOrigin(
 474       PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
 475       const AtomicBool& aCanceled) override;
 476
 477   void OnOriginClearCompleted(PersistenceType aPersistenceType,
 478                               const nsACString& aOrigin) override;
 479
 480   void OnRepositoryClearCompleted(PersistenceType aPersistenceType) override;
 481
 482   void ReleaseIOThreadObjects() override;
 483
 484   void AbortOperationsForLocks(
 485       const DirectoryLockIdTable& aDirectoryLockIds) override;
 486
 487   void AbortOperationsForProcess(ContentParentId aContentParentId) override;
 488
 489   void AbortAllOperations() override;
 490
 491   void StartIdleMaintenance() override;
 492
 493   void StopIdleMaintenance() override;
 494
 495  private:
 496   ~QuotaClient() override;
 497
 498   void InitiateShutdown() override;
 499   bool IsShutdownCompleted() const override;
 500   nsCString GetShutdownStatus() const override;
 501   void ForceKillActors() override;
 502   void FinalizeShutdown() override;
 503 };
 504
 505 /*******************************************************************************
 506  * Globals
 507  ******************************************************************************/
 508
 509 using ConnectionArray = nsTArray<NotNull<RefPtr<Connection>>>;
 510
 511 StaticAutoPtr<ConnectionArray> gOpenConnections;
 512
 513 template <typename Condition>
 514 void AllowToCloseConnectionsMatching(const Condition& aCondition) {
 515   AssertIsOnBackgroundThread();
 516
 517   if (gOpenConnections) {
 518     for (const auto& connection : *gOpenConnections) {
 519       if (aCondition(*connection)) {
 520         connection->AllowToClose();
 521       }
 522     }
 523   }
 524 }
 525
 526 }  // namespace
 527
 528 /*******************************************************************************
 529  * Exported functions
 530  ******************************************************************************/
 531
 532 PBackgroundSDBConnectionParent* AllocPBackgroundSDBConnectionParent(
 533     const PersistenceType& aPersistenceType,
 534     const PrincipalInfo& aPrincipalInfo) {
 535   AssertIsOnBackgroundThread();
 536
 537   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread())) {
 538     return nullptr;
 539   }
 540
 541   if (NS_WARN_IF(!IsValidPersistenceType(aPersistenceType))) {
 542     MOZ_CRASH_UNLESS_FUZZING();
 543     return nullptr;
 544   }
 545
 546   if (NS_WARN_IF(aPrincipalInfo.type() == PrincipalInfo::TNullPrincipalInfo)) {
 547     MOZ_CRASH_UNLESS_FUZZING();
 548     return nullptr;
 549   }
 550
 551   if (NS_WARN_IF(!QuotaManager::IsPrincipalInfoValid(aPrincipalInfo))) {
 552     MOZ_CRASH_UNLESS_FUZZING();
 553     return nullptr;
 554   }
 555
 556   RefPtr<Connection> actor = new Connection(aPersistenceType, aPrincipalInfo);
 557
 558   return actor.forget().take();
 559 }
 560
 561 bool RecvPBackgroundSDBConnectionConstructor(
 562     PBackgroundSDBConnectionParent* aActor,
 563     const PersistenceType& aPersistenceType,
 564     const PrincipalInfo& aPrincipalInfo) {
 565   AssertIsOnBackgroundThread();
 566   MOZ_ASSERT(aActor);
 567   MOZ_ASSERT(!QuotaClient::IsShuttingDownOnBackgroundThread());
 568
 569   return true;
 570 }
 571
 572 bool DeallocPBackgroundSDBConnectionParent(
 573     PBackgroundSDBConnectionParent* aActor) {
 574   AssertIsOnBackgroundThread();
 575   MOZ_ASSERT(aActor);
 576
 577   RefPtr<Connection> actor = dont_AddRef(static_cast<Connection*>(aActor));
 578   return true;
 579 }
 580
 581 namespace simpledb {
 582
 583 already_AddRefed<mozilla::dom::quota::Client> CreateQuotaClient() {
 584   AssertIsOnBackgroundThread();
 585
 586   RefPtr<QuotaClient> client = new QuotaClient();
 587   return client.forget();
 588 }
 589
 590 }  // namespace simpledb
 591
 592 /*******************************************************************************
 593  * StreamHelper
 594  ******************************************************************************/
 595
 596 StreamHelper::StreamHelper(nsIFileRandomAccessStream* aFileRandomAccessStream,
 597                            nsIRunnable* aCallback)
 598     : Runnable("dom::StreamHelper"),
 599       mOwningEventTarget(GetCurrentSerialEventTarget()),
 600       mFileRandomAccessStream(aFileRandomAccessStream),
 601       mCallback(aCallback) {
 602   AssertIsOnBackgroundThread();
 603   MOZ_ASSERT(aFileRandomAccessStream);
 604   MOZ_ASSERT(aCallback);
 605 }
 606
 607 StreamHelper::~StreamHelper() {
 608   MOZ_ASSERT(!mFileRandomAccessStream);
 609   MOZ_ASSERT(!mCallback);
 610 }
 611
 612 void StreamHelper::AsyncClose() {
 613   AssertIsOnBackgroundThread();
 614
 615   QuotaManager* quotaManager = QuotaManager::Get();
 616   MOZ_ASSERT(quotaManager);
 617
 618   MOZ_ALWAYS_SUCCEEDS(
 619       quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL));
 620 }
 621
 622 void StreamHelper::RunOnBackgroundThread() {
 623   AssertIsOnBackgroundThread();
 624
 625   nsCOMPtr<nsIFileRandomAccessStream> fileRandomAccessStream;
 626   mFileRandomAccessStream.swap(fileRandomAccessStream);
 627
 628   nsCOMPtr<nsIRunnable> callback;
 629   mCallback.swap(callback);
 630
 631   callback->Run();
 632 }
 633
 634 void StreamHelper::RunOnIOThread() {
 635   AssertIsOnIOThread();
 636   MOZ_ASSERT(mFileRandomAccessStream);
 637
 638   nsCOMPtr<nsIInputStream> inputStream =
 639       do_QueryInterface(mFileRandomAccessStream);
 640   MOZ_ASSERT(inputStream);
 641
 642   nsresult rv = inputStream->Close();
 643   Unused << NS_WARN_IF(NS_FAILED(rv));
 644
 645   MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
 646 }
 647
 648 NS_IMETHODIMP
 649 StreamHelper::Run() {
 650   MOZ_ASSERT(mCallback);
 651
 652   if (IsOnBackgroundThread()) {
 653     RunOnBackgroundThread();
 654   } else {
 655     RunOnIOThread();
 656   }
 657
 658   return NS_OK;
 659 }
 660
 661 /*******************************************************************************
 662  * Connection
 663  ******************************************************************************/
 664
 665 Connection::Connection(PersistenceType aPersistenceType,
 666                        const PrincipalInfo& aPrincipalInfo)
 667     : mPrincipalInfo(aPrincipalInfo),
 668       mPersistenceType(aPersistenceType),
 669       mRunningRequest(false),
 670       mOpen(false),
 671       mAllowedToClose(false),
 672       mActorDestroyed(false) {
 673   AssertIsOnBackgroundThread();
 674   MOZ_ASSERT(!QuotaClient::IsShuttingDownOnBackgroundThread());
 675 }
 676
 677 Connection::~Connection() {
 678   MOZ_ASSERT(!mRunningRequest);
 679   MOZ_ASSERT(!mOpen);
 680   MOZ_ASSERT(mActorDestroyed);
 681 }
 682
 683 void Connection::OnNewRequest() {
 684   AssertIsOnBackgroundThread();
 685   MOZ_ASSERT(!mRunningRequest);
 686
 687   mRunningRequest = true;
 688 }
 689
 690 void Connection::OnRequestFinished() {
 691   AssertIsOnBackgroundThread();
 692   MOZ_ASSERT(mRunningRequest);
 693
 694   mRunningRequest = false;
 695
 696   MaybeCloseStream();
 697 }
 698
 699 void Connection::OnOpen(
 700     const nsACString& aOrigin, const nsAString& aName,
 701     already_AddRefed<DirectoryLock> aDirectoryLock,
 702     already_AddRefed<nsIFileRandomAccessStream> aFileRandomAccessStream) {
 703   AssertIsOnBackgroundThread();
 704   MOZ_ASSERT(!aOrigin.IsEmpty());
 705   MOZ_ASSERT(!aName.IsEmpty());
 706   MOZ_ASSERT(mOrigin.IsEmpty());
 707   MOZ_ASSERT(mName.IsEmpty());
 708   MOZ_ASSERT(!mDirectoryLock);
 709   MOZ_ASSERT(!mFileRandomAccessStream);
 710   MOZ_ASSERT(!mOpen);
 711
 712   mOrigin = aOrigin;
 713   mName = aName;
 714   mDirectoryLock = aDirectoryLock;
 715   mFileRandomAccessStream = aFileRandomAccessStream;
 716   mOpen = true;
 717
 718   if (!gOpenConnections) {
 719     gOpenConnections = new ConnectionArray();
 720   }
 721
 722   gOpenConnections->AppendElement(WrapNotNullUnchecked(this));
 723 }
 724
 725 void Connection::OnClose() {
 726   AssertIsOnBackgroundThread();
 727   MOZ_ASSERT(!mOrigin.IsEmpty());
 728   MOZ_ASSERT(mDirectoryLock);
 729   MOZ_ASSERT(mFileRandomAccessStream);
 730   MOZ_ASSERT(mOpen);
 731
 732   mOrigin.Truncate();
 733   mName.Truncate();
 734   mDirectoryLock = nullptr;
 735   mFileRandomAccessStream = nullptr;
 736   mOpen = false;
 737
 738   MOZ_ASSERT(gOpenConnections);
 739   gOpenConnections->RemoveElement(this);
 740
 741   if (gOpenConnections->IsEmpty()) {
 742     gOpenConnections = nullptr;
 743   }
 744
 745   if (mAllowedToClose && !mActorDestroyed) {
 746     Unused << SendClosed();
 747   }
 748 }
 749
 750 void Connection::AllowToClose() {
 751   AssertIsOnBackgroundThread();
 752
 753   if (mAllowedToClose) {
 754     return;
 755   }
 756
 757   mAllowedToClose = true;
 758
 759   if (!mActorDestroyed) {
 760     Unused << SendAllowToClose();
 761   }
 762
 763   MaybeCloseStream();
 764 }
 765
 766 void Connection::MaybeCloseStream() {
 767   AssertIsOnBackgroundThread();
 768
 769   if (!mRunningRequest && mOpen && mAllowedToClose) {
 770     nsCOMPtr<nsIRunnable> callback = NewRunnableMethod(
 771         "dom::Connection::OnClose", this, &Connection::OnClose);
 772
 773     RefPtr<StreamHelper> helper =
 774         new StreamHelper(mFileRandomAccessStream, callback);
 775     helper->AsyncClose();
 776   }
 777 }
 778
 779 bool Connection::VerifyRequestParams(const SDBRequestParams& aParams) const {
 780   AssertIsOnBackgroundThread();
 781   MOZ_ASSERT(aParams.type() != SDBRequestParams::T__None);
 782
 783   switch (aParams.type()) {
 784     case SDBRequestParams::TSDBRequestOpenParams: {
 785       if (NS_WARN_IF(mOpen)) {
 786         MOZ_CRASH_UNLESS_FUZZING();
 787         return false;
 788       }
 789
 790       break;
 791     }
 792
 793     case SDBRequestParams::TSDBRequestSeekParams:
 794     case SDBRequestParams::TSDBRequestReadParams:
 795     case SDBRequestParams::TSDBRequestWriteParams:
 796     case SDBRequestParams::TSDBRequestCloseParams: {
 797       if (NS_WARN_IF(!mOpen)) {
 798         MOZ_CRASH_UNLESS_FUZZING();
 799         return false;
 800       }
 801
 802       break;
 803     }
 804
 805     default:
 806       MOZ_CRASH("Should never get here!");
 807   }
 808
 809   return true;
 810 }
 811
 812 void Connection::ActorDestroy(ActorDestroyReason aWhy) {
 813   AssertIsOnBackgroundThread();
 814   MOZ_ASSERT(!mActorDestroyed);
 815
 816   mActorDestroyed = true;
 817
 818   AllowToClose();
 819 }
 820
 821 mozilla::ipc::IPCResult Connection::RecvDeleteMe() {
 822   AssertIsOnBackgroundThread();
 823   MOZ_ASSERT(!mActorDestroyed);
 824
 825   IProtocol* mgr = Manager();
 826   if (!PBackgroundSDBConnectionParent::Send__delete__(this)) {
 827     return IPC_FAIL_NO_REASON(mgr);
 828   }
 829
 830   return IPC_OK();
 831 }
 832
 833 PBackgroundSDBRequestParent* Connection::AllocPBackgroundSDBRequestParent(
 834     const SDBRequestParams& aParams) {
 835   AssertIsOnBackgroundThread();
 836   MOZ_ASSERT(aParams.type() != SDBRequestParams::T__None);
 837
 838   if (aParams.type() == SDBRequestParams::TSDBRequestOpenParams &&
 839       NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread())) {
 840     return nullptr;
 841   }
 842
 843   if (mAllowedToClose) {
 844     return nullptr;
 845   }
 846
 847 #ifdef DEBUG
 848   // Always verify parameters in DEBUG builds!
 849   bool trustParams = false;
 850 #else
 851   PBackgroundParent* backgroundActor = Manager();
 852   MOZ_ASSERT(backgroundActor);
 853
 854   bool trustParams = !BackgroundParent::IsOtherProcessActor(backgroundActor);
 855 #endif
 856
 857   if (NS_WARN_IF(!trustParams && !VerifyRequestParams(aParams))) {
 858     MOZ_CRASH_UNLESS_FUZZING();
 859     return nullptr;
 860   }
 861
 862   if (NS_WARN_IF(mRunningRequest)) {
 863     MOZ_CRASH_UNLESS_FUZZING();
 864     return nullptr;
 865   }
 866
 867   QM_TRY(QuotaManager::EnsureCreated(), nullptr);
 868
 869   RefPtr<ConnectionOperationBase> actor;
 870
 871   switch (aParams.type()) {
 872     case SDBRequestParams::TSDBRequestOpenParams:
 873       actor = new OpenOp(this, aParams);
 874       break;
 875
 876     case SDBRequestParams::TSDBRequestSeekParams:
 877       actor = new SeekOp(this, aParams);
 878       break;
 879
 880     case SDBRequestParams::TSDBRequestReadParams:
 881       actor = new ReadOp(this, aParams);
 882       break;
 883
 884     case SDBRequestParams::TSDBRequestWriteParams:
 885       actor = new WriteOp(this, aParams);
 886       break;
 887
 888     case SDBRequestParams::TSDBRequestCloseParams:
 889       actor = new CloseOp(this);
 890       break;
 891
 892     default:
 893       MOZ_CRASH("Should never get here!");
 894   }
 895
 896   // Transfer ownership to IPDL.
 897   return actor.forget().take();
 898 }
 899
 900 mozilla::ipc::IPCResult Connection::RecvPBackgroundSDBRequestConstructor(
 901     PBackgroundSDBRequestParent* aActor, const SDBRequestParams& aParams) {
 902   AssertIsOnBackgroundThread();
 903   MOZ_ASSERT(aActor);
 904   MOZ_ASSERT(aParams.type() != SDBRequestParams::T__None);
 905   MOZ_ASSERT_IF(aParams.type() == SDBRequestParams::TSDBRequestOpenParams,
 906                 !QuotaClient::IsShuttingDownOnBackgroundThread());
 907   MOZ_ASSERT(!mAllowedToClose);
 908   MOZ_ASSERT(!mRunningRequest);
 909
 910   auto* op = static_cast<ConnectionOperationBase*>(aActor);
 911
 912   if (NS_WARN_IF(!op->Init())) {
 913     op->Cleanup();
 914     return IPC_FAIL_NO_REASON(this);
 915   }
 916
 917   if (NS_WARN_IF(NS_FAILED(op->Dispatch()))) {
 918     op->Cleanup();
 919     return IPC_FAIL_NO_REASON(this);
 920   }
 921
 922   return IPC_OK();
 923 }
 924
 925 bool Connection::DeallocPBackgroundSDBRequestParent(
 926     PBackgroundSDBRequestParent* aActor) {
 927   AssertIsOnBackgroundThread();
 928   MOZ_ASSERT(aActor);
 929
 930   // Transfer ownership back from IPDL.
 931   RefPtr<ConnectionOperationBase> actor =
 932       dont_AddRef(static_cast<ConnectionOperationBase*>(aActor));
 933   return true;
 934 }
 935
 936 /*******************************************************************************
 937  * ConnectionOperationBase
 938  ******************************************************************************/
 939
 940 ConnectionOperationBase::~ConnectionOperationBase() {
 941   MOZ_ASSERT(
 942       !mConnection,
 943       "ConnectionOperationBase::Cleanup() was not called by a subclass!");
 944   MOZ_ASSERT(mActorDestroyed);
 945 }
 946
 947 bool ConnectionOperationBase::Init() {
 948   AssertIsOnBackgroundThread();
 949   MOZ_ASSERT(mConnection);
 950
 951   mConnection->OnNewRequest();
 952
 953   return true;
 954 }
 955
 956 nsresult ConnectionOperationBase::Dispatch() {
 957   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread()) ||
 958       IsActorDestroyed()) {
 959     return NS_ERROR_ABORT;
 960   }
 961
 962   QuotaManager* quotaManager = QuotaManager::Get();
 963   MOZ_ASSERT(quotaManager);
 964
 965   nsresult rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
 966   if (NS_WARN_IF(NS_FAILED(rv))) {
 967     return rv;
 968   }
 969
 970   return NS_OK;
 971 }
 972
 973 void ConnectionOperationBase::Cleanup() {
 974   AssertIsOnOwningThread();
 975   MOZ_ASSERT(mConnection);
 976
 977   mConnection->OnRequestFinished();
 978
 979   mConnection = nullptr;
 980 }
 981
 982 void ConnectionOperationBase::SendResults() {
 983   AssertIsOnOwningThread();
 984
 985   if (IsActorDestroyed()) {
 986     MaybeSetFailureCode(NS_ERROR_FAILURE);
 987   } else {
 988     SDBRequestResponse response;
 989
 990     if (NS_SUCCEEDED(mResultCode)) {
 991       GetResponse(response);
 992
 993       MOZ_ASSERT(response.type() != SDBRequestResponse::T__None);
 994       MOZ_ASSERT(response.type() != SDBRequestResponse::Tnsresult);
 995     } else {
 996       response = mResultCode;
 997     }
 998
 999     Unused << PBackgroundSDBRequestParent::Send__delete__(this, response);
1000
1001     if (NS_SUCCEEDED(mResultCode)) {
1002       OnSuccess();
1003     }
1004   }
1005
1006   Cleanup();
1007 }
1008
1009 void ConnectionOperationBase::DatabaseWork() {
1010   AssertIsOnIOThread();
1011   MOZ_ASSERT(NS_SUCCEEDED(mResultCode));
1012
1013   if (!OperationMayProceed()) {
1014     // The operation was canceled in some way, likely because the child process
1015     // has crashed.
1016     mResultCode = NS_ERROR_ABORT;
1017   } else {
1018     nsIFileRandomAccessStream* fileRandomAccessStream =
1019         mConnection->GetFileRandomAccessStream();
1020     MOZ_ASSERT(fileRandomAccessStream);
1021
1022     nsresult rv = DoDatabaseWork(fileRandomAccessStream);
1023     if (NS_FAILED(rv)) {
1024       mResultCode = rv;
1025     }
1026   }
1027
1028   MOZ_ALWAYS_SUCCEEDS(mOwningEventTarget->Dispatch(this, NS_DISPATCH_NORMAL));
1029 }
1030
1031 void ConnectionOperationBase::OnSuccess() { AssertIsOnOwningThread(); }
1032
1033 NS_IMETHODIMP
1034 ConnectionOperationBase::Run() {
1035   if (IsOnBackgroundThread()) {
1036     SendResults();
1037   } else {
1038     DatabaseWork();
1039   }
1040
1041   return NS_OK;
1042 }
1043
1044 void ConnectionOperationBase::ActorDestroy(ActorDestroyReason aWhy) {
1045   AssertIsOnBackgroundThread();
1046
1047   mOperationMayProceed = false;
1048   mActorDestroyed = true;
1049 }
1050
1051 OpenOp::OpenOp(Connection* aConnection, const SDBRequestParams& aParams)
1052     : ConnectionOperationBase(aConnection),
1053       mParams(aParams.get_SDBRequestOpenParams()),
1054       mState(State::Initial),
1055       mFileRandomAccessStreamOpen(false) {
1056   MOZ_ASSERT(aParams.type() == SDBRequestParams::TSDBRequestOpenParams);
1057 }
1058
1059 OpenOp::~OpenOp() {
1060   MOZ_ASSERT(!mDirectoryLock);
1061   MOZ_ASSERT(!mFileRandomAccessStream);
1062   MOZ_ASSERT(!mFileRandomAccessStreamOpen);
1063   MOZ_ASSERT_IF(OperationMayProceed(),
1064                 mState == State::Initial || mState == State::Completed);
1065 }
1066
1067 nsresult OpenOp::Dispatch() {
1068   MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));
1069
1070   return NS_OK;
1071 }
1072
1073 nsresult OpenOp::Open() {
1074   MOZ_ASSERT(NS_IsMainThread());
1075   MOZ_ASSERT(mState == State::Initial);
1076
1077   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnNonBackgroundThread()) ||
1078       !OperationMayProceed()) {
1079     return NS_ERROR_ABORT;
1080   }
1081
1082   if (NS_WARN_IF(!Preferences::GetBool(kPrefSimpleDBEnabled, false))) {
1083     return NS_ERROR_UNEXPECTED;
1084   }
1085
1086   mState = State::FinishOpen;
1087   MOZ_ALWAYS_SUCCEEDS(OwningEventTarget()->Dispatch(this, NS_DISPATCH_NORMAL));
1088
1089   return NS_OK;
1090 }
1091
1092 nsresult OpenOp::FinishOpen() {
1093   AssertIsOnOwningThread();
1094   MOZ_ASSERT(mOriginMetadata.mOrigin.IsEmpty());
1095   MOZ_ASSERT(!mDirectoryLock);
1096   MOZ_ASSERT(mState == State::FinishOpen);
1097
1098   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread()) ||
1099       IsActorDestroyed()) {
1100     return NS_ERROR_ABORT;
1101   }
1102
1103   QuotaManager* quotaManager = QuotaManager::Get();
1104   MOZ_ASSERT(quotaManager);
1105
1106   const PrincipalInfo& principalInfo = GetConnection()->GetPrincipalInfo();
1107
1108   PersistenceType persistenceType = GetConnection()->GetPersistenceType();
1109
1110   if (principalInfo.type() == PrincipalInfo::TSystemPrincipalInfo) {
1111     mOriginMetadata = {QuotaManager::GetInfoForChrome(), persistenceType};
1112   } else {
1113     MOZ_ASSERT(principalInfo.type() == PrincipalInfo::TContentPrincipalInfo);
1114
1115     QM_TRY_UNWRAP(
1116         auto principalMetadata,
1117         quotaManager->GetInfoFromValidatedPrincipalInfo(principalInfo));
1118
1119     mOriginMetadata = {std::move(principalMetadata), persistenceType};
1120   }
1121
1122   if (gOpenConnections) {
1123     for (const auto& connection : *gOpenConnections) {
1124       if (connection->Origin() == mOriginMetadata.mOrigin &&
1125           connection->Name() == mParams.name()) {
1126         return NS_ERROR_STORAGE_BUSY;
1127       }
1128     }
1129   }
1130
1131   // Open the directory
1132
1133   RefPtr<DirectoryLock> directoryLock = quotaManager->CreateDirectoryLock(
1134       GetConnection()->GetPersistenceType(), mOriginMetadata,
1135       mozilla::dom::quota::Client::SDB,
1136       /* aExclusive */ false);
1137
1138   mState = State::DirectoryOpenPending;
1139   directoryLock->Acquire(this);
1140
1141   return NS_OK;
1142 }
1143
1144 nsresult OpenOp::SendToIOThread() {
1145   AssertIsOnOwningThread();
1146   MOZ_ASSERT(mState == State::DirectoryOpenPending);
1147
1148   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnBackgroundThread()) ||
1149       IsActorDestroyed()) {
1150     return NS_ERROR_ABORT;
1151   }
1152
1153   mFileRandomAccessStream = new FileRandomAccessStream(
1154       GetConnection()->GetPersistenceType(), mOriginMetadata,
1155       mozilla::dom::quota::Client::SDB);
1156
1157   QuotaManager* quotaManager = QuotaManager::Get();
1158   MOZ_ASSERT(quotaManager);
1159
1160   // Must set this before dispatching otherwise we will race with the IO thread.
1161   mState = State::DatabaseWorkOpen;
1162
1163   nsresult rv = quotaManager->IOThread()->Dispatch(this, NS_DISPATCH_NORMAL);
1164   if (NS_WARN_IF(NS_FAILED(rv))) {
1165     return rv;
1166   }
1167
1168   return NS_OK;
1169 }
1170
1171 nsresult OpenOp::DatabaseWork() {
1172   AssertIsOnIOThread();
1173   MOZ_ASSERT(mState == State::DatabaseWorkOpen);
1174   MOZ_ASSERT(mFileRandomAccessStream);
1175   MOZ_ASSERT(!mFileRandomAccessStreamOpen);
1176
1177   if (NS_WARN_IF(QuotaClient::IsShuttingDownOnNonBackgroundThread()) ||
1178       !OperationMayProceed()) {
1179     return NS_ERROR_ABORT;
1180   }
1181
1182   QuotaManager* quotaManager = QuotaManager::Get();
1183   MOZ_ASSERT(quotaManager);
1184
1185   QM_TRY(MOZ_TO_RESULT(quotaManager->EnsureStorageIsInitialized()));
1186
1187   QM_TRY_INSPECT(
1188       const auto& dbDirectory,
1189       ([persistenceType = GetConnection()->GetPersistenceType(), &quotaManager,
1190         this]()
1191            -> mozilla::Result<std::pair<nsCOMPtr<nsIFile>, bool>, nsresult> {
1192         if (persistenceType == PERSISTENCE_TYPE_PERSISTENT) {
1193           QM_TRY_RETURN(quotaManager->EnsurePersistentOriginIsInitialized(
1194               mOriginMetadata));
1195         }
1196
1197         QM_TRY(
1198             MOZ_TO_RESULT(quotaManager->EnsureTemporaryStorageIsInitialized()));
1199         QM_TRY_RETURN(quotaManager->EnsureTemporaryOriginIsInitialized(
1200             persistenceType, mOriginMetadata));
1201       }()
1202                   .map([](const auto& res) { return res.first; })));
1203
1204   nsresult rv =
1205       dbDirectory->Append(NS_LITERAL_STRING_FROM_CSTRING(SDB_DIRECTORY_NAME));
1206   if (NS_WARN_IF(NS_FAILED(rv))) {
1207     return rv;
1208   }
1209
1210   bool exists;
1211   rv = dbDirectory->Exists(&exists);
1212   if (NS_WARN_IF(NS_FAILED(rv))) {
1213     return rv;
1214   }
1215
1216   if (!exists) {
1217     rv = dbDirectory->Create(nsIFile::DIRECTORY_TYPE, 0755);
1218     if (NS_WARN_IF(NS_FAILED(rv))) {
1219       return rv;
1220     }
1221   }
1222 #ifdef DEBUG
1223   else {
1224     bool isDirectory;
1225     MOZ_ASSERT(NS_SUCCEEDED(dbDirectory->IsDirectory(&isDirectory)));
1226     MOZ_ASSERT(isDirectory);
1227   }
1228 #endif
1229
1230   nsCOMPtr<nsIFile> dbFile;
1231   rv = dbDirectory->Clone(getter_AddRefs(dbFile));
1232   if (NS_WARN_IF(NS_FAILED(rv))) {
1233     return rv;
1234   }
1235
1236   rv = dbFile->Append(mParams.name() + kSDBSuffix);
1237   if (NS_WARN_IF(NS_FAILED(rv))) {
1238     return rv;
1239   }
1240
1241   nsString databaseFilePath;
1242   rv = dbFile->GetPath(databaseFilePath);
1243   if (NS_WARN_IF(NS_FAILED(rv))) {
1244     return rv;
1245   }
1246
1247   rv = mFileRandomAccessStream->Init(dbFile, PR_RDWR | PR_CREATE_FILE, 0644, 0);
1248   if (NS_WARN_IF(NS_FAILED(rv))) {
1249     return rv;
1250   }
1251
1252   mFileRandomAccessStreamOpen = true;
1253
1254   rv = DoDatabaseWork(mFileRandomAccessStream);
1255   if (NS_WARN_IF(NS_FAILED(rv))) {
1256     return rv;
1257   }
1258
1259   // Must set mState before dispatching otherwise we will race with the owning
1260   // thread.
1261   mState = State::SendingResults;
1262
1263   rv = OwningEventTarget()->Dispatch(this, NS_DISPATCH_NORMAL);
1264   if (NS_WARN_IF(NS_FAILED(rv))) {
1265     return rv;
1266   }
1267
1268   return NS_OK;
1269 }
1270
1271 void OpenOp::StreamClosedCallback() {
1272   AssertIsOnOwningThread();
1273   MOZ_ASSERT(NS_FAILED(ResultCode()));
1274   MOZ_ASSERT(mDirectoryLock);
1275   MOZ_ASSERT(mFileRandomAccessStream);
1276   MOZ_ASSERT(mFileRandomAccessStreamOpen);
1277
1278   mDirectoryLock = nullptr;
1279   mFileRandomAccessStream = nullptr;
1280   mFileRandomAccessStreamOpen = false;
1281 }
1282
1283 nsresult OpenOp::DoDatabaseWork(
1284     nsIFileRandomAccessStream* aFileRandomAccessStream) {
1285   AssertIsOnIOThread();
1286
1287   return NS_OK;
1288 }
1289
1290 void OpenOp::GetResponse(SDBRequestResponse& aResponse) {
1291   AssertIsOnOwningThread();
1292
1293   aResponse = SDBRequestOpenResponse();
1294 }
1295
1296 void OpenOp::OnSuccess() {
1297   AssertIsOnOwningThread();
1298   MOZ_ASSERT(NS_SUCCEEDED(ResultCode()));
1299   MOZ_ASSERT(!mOriginMetadata.mOrigin.IsEmpty());
1300   MOZ_ASSERT(mDirectoryLock);
1301   MOZ_ASSERT(mFileRandomAccessStream);
1302   MOZ_ASSERT(mFileRandomAccessStreamOpen);
1303
1304   RefPtr<DirectoryLock> directoryLock;
1305   nsCOMPtr<nsIFileRandomAccessStream> fileRandomAccessStream;
1306
1307   mDirectoryLock.swap(directoryLock);
1308   mFileRandomAccessStream.swap(fileRandomAccessStream);
1309   mFileRandomAccessStreamOpen = false;
1310
1311   GetConnection()->OnOpen(mOriginMetadata.mOrigin, mParams.name(),
1312                           directoryLock.forget(),
1313                           fileRandomAccessStream.forget());
1314 }
1315
1316 void OpenOp::Cleanup() {
1317   AssertIsOnOwningThread();
1318   MOZ_ASSERT_IF(mFileRandomAccessStreamOpen, mFileRandomAccessStream);
1319
1320   if (mFileRandomAccessStream && mFileRandomAccessStreamOpen) {
1321     // If we have an initialized file stream then the operation must have failed
1322     // and there must be a directory lock too.
1323     MOZ_ASSERT(NS_FAILED(ResultCode()));
1324     MOZ_ASSERT(mDirectoryLock);
1325
1326     // We must close the stream on the I/O thread before releasing it on this
1327     // thread. The directory lock can't be released either.
1328     nsCOMPtr<nsIRunnable> callback =
1329         NewRunnableMethod("dom::OpenOp::StreamClosedCallback", this,
1330                           &OpenOp::StreamClosedCallback);
1331
1332     RefPtr<StreamHelper> helper =
1333         new StreamHelper(mFileRandomAccessStream, callback);
1334     helper->AsyncClose();
1335   } else {
1336     MOZ_ASSERT(!mFileRandomAccessStreamOpen);
1337
1338     mDirectoryLock = nullptr;
1339     mFileRandomAccessStream = nullptr;
1340   }
1341
1342   ConnectionOperationBase::Cleanup();
1343 }
1344
1345 NS_IMPL_ISUPPORTS_INHERITED0(OpenOp, ConnectionOperationBase)
1346
1347 NS_IMETHODIMP
1348 OpenOp::Run() {
1349   nsresult rv;
1350
1351   switch (mState) {
1352     case State::Initial:
1353       rv = Open();
1354       break;
1355
1356     case State::FinishOpen:
1357       rv = FinishOpen();
1358       break;
1359
1360     case State::DatabaseWorkOpen:
1361       rv = DatabaseWork();
1362       break;
1363
1364     case State::SendingResults:
1365       SendResults();
1366       return NS_OK;
1367
1368     default:
1369       MOZ_CRASH("Bad state!");
1370   }
1371
1372   if (NS_WARN_IF(NS_FAILED(rv)) && mState != State::SendingResults) {
1373     MaybeSetFailureCode(rv);
1374
1375     // Must set mState before dispatching otherwise we will race with the owning
1376     // thread.
1377     mState = State::SendingResults;
1378
1379     if (IsOnOwningThread()) {
1380       SendResults();
1381     } else {
1382       MOZ_ALWAYS_SUCCEEDS(
1383           OwningEventTarget()->Dispatch(this, NS_DISPATCH_NORMAL));
1384     }
1385   }
1386
1387   return NS_OK;
1388 }
1389
1390 void OpenOp::DirectoryLockAcquired(DirectoryLock* aLock) {
1391   AssertIsOnOwningThread();
1392   MOZ_ASSERT(mState == State::DirectoryOpenPending);
1393   MOZ_ASSERT(!mDirectoryLock);
1394
1395   mDirectoryLock = aLock;
1396
1397   nsresult rv = SendToIOThread();
1398   if (NS_WARN_IF(NS_FAILED(rv))) {
1399     MaybeSetFailureCode(rv);
1400
1401     // The caller holds a strong reference to us, no need for a self reference
1402     // before calling Run().
1403
1404     mState = State::SendingResults;
1405     MOZ_ALWAYS_SUCCEEDS(Run());
1406
1407     return;
1408   }
1409 }
1410
1411 void OpenOp::DirectoryLockFailed() {
1412   AssertIsOnOwningThread();
1413   MOZ_ASSERT(mState == State::DirectoryOpenPending);
1414   MOZ_ASSERT(!mDirectoryLock);
1415
1416   MaybeSetFailureCode(NS_ERROR_FAILURE);
1417
1418   // The caller holds a strong reference to us, no need for a self reference
1419   // before calling Run().
1420
1421   mState = State::SendingResults;
1422   MOZ_ALWAYS_SUCCEEDS(Run());
1423 }
1424
1425 SeekOp::SeekOp(Connection* aConnection, const SDBRequestParams& aParams)
1426     : ConnectionOperationBase(aConnection),
1427       mParams(aParams.get_SDBRequestSeekParams()) {
1428   MOZ_ASSERT(aParams.type() == SDBRequestParams::TSDBRequestSeekParams);
1429 }
1430
1431 nsresult SeekOp::DoDatabaseWork(
1432     nsIFileRandomAccessStream* aFileRandomAccessStream) {
1433   AssertIsOnIOThread();
1434   MOZ_ASSERT(aFileRandomAccessStream);
1435
1436   nsresult rv = aFileRandomAccessStream->Seek(nsISeekableStream::NS_SEEK_SET,
1437                                               mParams.offset());
1438
1439   if (NS_WARN_IF(NS_FAILED(rv))) {
1440     return rv;
1441   }
1442
1443   return NS_OK;
1444 }
1445
1446 void SeekOp::GetResponse(SDBRequestResponse& aResponse) {
1447   aResponse = SDBRequestSeekResponse();
1448 }
1449
1450 ReadOp::ReadOp(Connection* aConnection, const SDBRequestParams& aParams)
1451     : ConnectionOperationBase(aConnection),
1452       mParams(aParams.get_SDBRequestReadParams()) {
1453   MOZ_ASSERT(aParams.type() == SDBRequestParams::TSDBRequestReadParams);
1454 }
1455
1456 bool ReadOp::Init() {
1457   AssertIsOnOwningThread();
1458
1459   if (NS_WARN_IF(!ConnectionOperationBase::Init())) {
1460     return false;
1461   }
1462
1463   if (NS_WARN_IF(mParams.size() > std::numeric_limits<std::size_t>::max())) {
1464     return false;
1465   }
1466
1467   mOutputStream = FixedBufferOutputStream::Create(mParams.size(), fallible);
1468   if (NS_WARN_IF(!mOutputStream)) {
1469     return false;
1470   }
1471
1472   return true;
1473 }
1474
1475 nsresult ReadOp::DoDatabaseWork(
1476     nsIFileRandomAccessStream* aFileRandomAccessStream) {
1477   AssertIsOnIOThread();
1478   MOZ_ASSERT(aFileRandomAccessStream);
1479
1480   nsCOMPtr<nsIInputStream> inputStream =
1481       do_QueryInterface(aFileRandomAccessStream);
1482   MOZ_ASSERT(inputStream);
1483
1484   nsresult rv;
1485
1486   uint64_t offset = 0;
1487
1488   do {
1489     char copyBuffer[kCopyBufferSize];
1490
1491     uint64_t max = mParams.size() - offset;
1492     if (max == 0) {
1493       break;
1494     }
1495
1496     uint32_t count = sizeof(copyBuffer);
1497     if (count > max) {
1498       count = max;
1499     }
1500
1501     uint32_t numRead;
1502     rv = inputStream->Read(copyBuffer, count, &numRead);
1503     if (NS_WARN_IF(NS_FAILED(rv))) {
1504       return rv;
1505     }
1506
1507     if (!numRead) {
1508       break;
1509     }
1510
1511     uint32_t numWrite;
1512     rv = mOutputStream->Write(copyBuffer, numRead, &numWrite);
1513     if (NS_WARN_IF(NS_FAILED(rv))) {
1514       return rv;
1515     }
1516
1517     if (NS_WARN_IF(numWrite != numRead)) {
1518       return NS_ERROR_FAILURE;
1519     }
1520
1521     offset += numWrite;
1522   } while (true);
1523
1524   MOZ_ASSERT(offset == mParams.size());
1525
1526   MOZ_ALWAYS_SUCCEEDS(mOutputStream->Close());
1527
1528   return NS_OK;
1529 }
1530
1531 void ReadOp::GetResponse(SDBRequestResponse& aResponse) {
1532   aResponse = SDBRequestReadResponse(nsCString(mOutputStream->WrittenData()));
1533 }
1534
1535 WriteOp::WriteOp(Connection* aConnection, const SDBRequestParams& aParams)
1536     : ConnectionOperationBase(aConnection),
1537       mParams(aParams.get_SDBRequestWriteParams()),
1538       mSize(0) {
1539   MOZ_ASSERT(aParams.type() == SDBRequestParams::TSDBRequestWriteParams);
1540 }
1541
1542 bool WriteOp::Init() {
1543   AssertIsOnOwningThread();
1544
1545   if (NS_WARN_IF(!ConnectionOperationBase::Init())) {
1546     return false;
1547   }
1548
1549   const nsCString& string = mParams.data();
1550
1551   nsCOMPtr<nsIInputStream> inputStream;
1552   nsresult rv = NS_NewCStringInputStream(getter_AddRefs(inputStream), string);
1553   if (NS_WARN_IF(NS_FAILED(rv))) {
1554     return false;
1555   }
1556
1557   mInputStream = std::move(inputStream);
1558   mSize = string.Length();
1559
1560   return true;
1561 }
1562
1563 nsresult WriteOp::DoDatabaseWork(
1564     nsIFileRandomAccessStream* aFileRandomAccessStream) {
1565   AssertIsOnIOThread();
1566   MOZ_ASSERT(aFileRandomAccessStream);
1567
1568   nsCOMPtr<nsIOutputStream> outputStream =
1569       do_QueryInterface(aFileRandomAccessStream);
1570   MOZ_ASSERT(outputStream);
1571
1572   nsresult rv;
1573
1574   do {
1575     char copyBuffer[kCopyBufferSize];
1576
1577     uint32_t numRead;
1578     rv = mInputStream->Read(copyBuffer, sizeof(copyBuffer), &numRead);
1579     if (NS_WARN_IF(NS_FAILED(rv))) {
1580       break;
1581     }
1582
1583     if (!numRead) {
1584       break;
1585     }
1586
1587     uint32_t numWrite;
1588     rv = outputStream->Write(copyBuffer, numRead, &numWrite);
1589     if (NS_WARN_IF(NS_FAILED(rv))) {
1590       return rv;
1591     }
1592
1593     if (NS_WARN_IF(numWrite != numRead)) {
1594       return NS_ERROR_FAILURE;
1595     }
1596   } while (true);
1597
1598   MOZ_ALWAYS_SUCCEEDS(mInputStream->Close());
1599
1600   return NS_OK;
1601 }
1602
1603 void WriteOp::GetResponse(SDBRequestResponse& aResponse) {
1604   aResponse = SDBRequestWriteResponse();
1605 }
1606
1607 CloseOp::CloseOp(Connection* aConnection)
1608     : ConnectionOperationBase(aConnection) {}
1609
1610 nsresult CloseOp::DoDatabaseWork(
1611     nsIFileRandomAccessStream* aFileRandomAccessStream) {
1612   AssertIsOnIOThread();
1613   MOZ_ASSERT(aFileRandomAccessStream);
1614
1615   nsCOMPtr<nsIInputStream> inputStream =
1616       do_QueryInterface(aFileRandomAccessStream);
1617   MOZ_ASSERT(inputStream);
1618
1619   nsresult rv = inputStream->Close();
1620   if (NS_WARN_IF(NS_FAILED(rv))) {
1621     return rv;
1622   }
1623
1624   return NS_OK;
1625 }
1626
1627 void CloseOp::GetResponse(SDBRequestResponse& aResponse) {
1628   aResponse = SDBRequestCloseResponse();
1629 }
1630
1631 void CloseOp::OnSuccess() {
1632   AssertIsOnOwningThread();
1633
1634   GetConnection()->OnClose();
1635 }
1636
1637 /*******************************************************************************
1638  * QuotaClient
1639  ******************************************************************************/
1640
1641 QuotaClient* QuotaClient::sInstance = nullptr;
1642
1643 QuotaClient::QuotaClient() {
1644   AssertIsOnBackgroundThread();
1645   MOZ_ASSERT(!sInstance, "We expect this to be a singleton!");
1646
1647   sInstance = this;
1648 }
1649
1650 QuotaClient::~QuotaClient() {
1651   AssertIsOnBackgroundThread();
1652   MOZ_ASSERT(sInstance == this, "We expect this to be a singleton!");
1653
1654   sInstance = nullptr;
1655 }
1656
1657 mozilla::dom::quota::Client::Type QuotaClient::GetType() {
1658   return QuotaClient::SDB;
1659 }
1660
1661 Result<UsageInfo, nsresult> QuotaClient::InitOrigin(
1662     PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
1663     const AtomicBool& aCanceled) {
1664   AssertIsOnIOThread();
1665
1666   return GetUsageForOrigin(aPersistenceType, aOriginMetadata, aCanceled);
1667 }
1668
1669 nsresult QuotaClient::InitOriginWithoutTracking(
1670     PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
1671     const AtomicBool& aCanceled) {
1672   AssertIsOnIOThread();
1673
1674   return NS_OK;
1675 }
1676
1677 Result<UsageInfo, nsresult> QuotaClient::GetUsageForOrigin(
1678     PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
1679     const AtomicBool& aCanceled) {
1680   AssertIsOnIOThread();
1681   MOZ_ASSERT(aOriginMetadata.mPersistenceType == aPersistenceType);
1682
1683   QuotaManager* quotaManager = QuotaManager::Get();
1684   MOZ_ASSERT(quotaManager);
1685
1686   QM_TRY_UNWRAP(auto directory,
1687                 quotaManager->GetOriginDirectory(aOriginMetadata));
1688
1689   MOZ_ASSERT(directory);
1690
1691   nsresult rv =
1692       directory->Append(NS_LITERAL_STRING_FROM_CSTRING(SDB_DIRECTORY_NAME));
1693   if (NS_WARN_IF(NS_FAILED(rv))) {
1694     return Err(rv);
1695   }
1696
1697   DebugOnly<bool> exists;
1698   MOZ_ASSERT(NS_SUCCEEDED(directory->Exists(&exists)) && exists);
1699
1700   QM_TRY_RETURN(ReduceEachFileAtomicCancelable(
1701       *directory, aCanceled, UsageInfo{},
1702       [](UsageInfo usageInfo,
1703          const nsCOMPtr<nsIFile>& file) -> Result<UsageInfo, nsresult> {
1704         QM_TRY_INSPECT(const bool& isDirectory,
1705                        MOZ_TO_RESULT_INVOKE_MEMBER(file, IsDirectory));
1706
1707         if (isDirectory) {
1708           Unused << WARN_IF_FILE_IS_UNKNOWN(*file);
1709           return usageInfo;
1710         }
1711
1712         nsString leafName;
1713         QM_TRY(MOZ_TO_RESULT(file->GetLeafName(leafName)));
1714
1715         if (StringEndsWith(leafName, kSDBSuffix)) {
1716           QM_TRY_INSPECT(const int64_t& fileSize,
1717                          MOZ_TO_RESULT_INVOKE_MEMBER(file, GetFileSize));
1718
1719           MOZ_ASSERT(fileSize >= 0);
1720
1721           return usageInfo +
1722                  UsageInfo{DatabaseUsageType(Some(uint64_t(fileSize)))};
1723         }
1724
1725         Unused << WARN_IF_FILE_IS_UNKNOWN(*file);
1726
1727         return usageInfo;
1728       }));
1729 }
1730
1731 void QuotaClient::OnOriginClearCompleted(PersistenceType aPersistenceType,
1732                                          const nsACString& aOrigin) {
1733   AssertIsOnIOThread();
1734 }
1735
1736 void QuotaClient::OnRepositoryClearCompleted(PersistenceType aPersistenceType) {
1737   AssertIsOnIOThread();
1738 }
1739
1740 void QuotaClient::ReleaseIOThreadObjects() { AssertIsOnIOThread(); }
1741
1742 void QuotaClient::AbortOperationsForLocks(
1743     const DirectoryLockIdTable& aDirectoryLockIds) {
1744   AssertIsOnBackgroundThread();
1745
1746   AllowToCloseConnectionsMatching([&aDirectoryLockIds](const auto& connection) {
1747     // If the connections is registered in gOpenConnections then it must have
1748     // a directory lock.
1749     return IsLockForObjectContainedInLockTable(connection, aDirectoryLockIds);
1750   });
1751 }
1752
1753 void QuotaClient::AbortOperationsForProcess(ContentParentId aContentParentId) {
1754   AssertIsOnBackgroundThread();
1755 }
1756
1757 void QuotaClient::AbortAllOperations() {
1758   AssertIsOnBackgroundThread();
1759
1760   AllowToCloseConnectionsMatching([](const auto&) { return true; });
1761 }
1762
1763 void QuotaClient::StartIdleMaintenance() { AssertIsOnBackgroundThread(); }
1764
1765 void QuotaClient::StopIdleMaintenance() { AssertIsOnBackgroundThread(); }
1766
1767 void QuotaClient::InitiateShutdown() {
1768   AssertIsOnBackgroundThread();
1769
1770   if (gOpenConnections) {
1771     for (const auto& connection : *gOpenConnections) {
1772       connection->AllowToClose();
1773     }
1774   }
1775 }
1776
1777 bool QuotaClient::IsShutdownCompleted() const { return !gOpenConnections; }
1778
1779 void QuotaClient::ForceKillActors() {
1780   // Currently we don't implement killing actors (are there any to kill here?).
1781 }
1782
1783 nsCString QuotaClient::GetShutdownStatus() const {
1784   // XXX Gather information here.
1785   return "To be implemented"_ns;
1786 }
1787
1788 void QuotaClient::FinalizeShutdown() {
1789   // Nothing to do here.
1790 }
1791
1792 }  // namespace mozilla::dom