dom/indexedDB/ActorsChild.h

   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 #ifndef mozilla_dom_indexeddb_actorschild_h__
   8 #define mozilla_dom_indexeddb_actorschild_h__
   9
  10 #include "js/RootingAPI.h"
  11 #include "mozilla/Attributes.h"
  12 #include "mozilla/dom/IDBCursorType.h"
  13 #include "mozilla/dom/IDBTransaction.h"
  14 #include "mozilla/dom/indexedDB/PBackgroundIDBCursorChild.h"
  15 #include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseChild.h"
  16 #include "mozilla/dom/indexedDB/PBackgroundIDBFactoryChild.h"
  17 #include "mozilla/dom/indexedDB/PBackgroundIDBFactoryRequestChild.h"
  18 #include "mozilla/dom/indexedDB/PBackgroundIDBRequestChild.h"
  19 #include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"
  20 #include "mozilla/dom/indexedDB/PBackgroundIDBTransactionChild.h"
  21 #include "mozilla/dom/indexedDB/PBackgroundIDBVersionChangeTransactionChild.h"
  22 #include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsChild.h"
  23 #include "mozilla/InitializedOnce.h"
  24 #include "mozilla/UniquePtr.h"
  25 #include "nsCOMPtr.h"
  26 #include "nsTArray.h"
  27
  28 class nsIEventTarget;
  29 struct nsID;
  30
  31 namespace mozilla {
  32 namespace ipc {
  33
  34 class BackgroundChildImpl;
  35
  36 }  // namespace ipc
  37
  38 namespace dom {
  39
  40 class IDBCursor;
  41 class IDBDatabase;
  42 class IDBFactory;
  43 class IDBOpenDBRequest;
  44 class IDBRequest;
  45 class IndexedDatabaseManager;
  46
  47 namespace indexedDB {
  48
  49 class Key;
  50 class PermissionRequestChild;
  51 class PermissionRequestParent;
  52 class SerializedStructuredCloneReadInfo;
  53 struct CloneInfo;
  54
  55 }  // namespace indexedDB
  56 }  // namespace dom
  57 }  // namespace mozilla
  58
  59 MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR(mozilla::dom::indexedDB::CloneInfo)
  60
  61 namespace mozilla::dom::indexedDB {
  62
  63 class BackgroundFactoryChild final : public PBackgroundIDBFactoryChild {
  64   friend class mozilla::ipc::BackgroundChildImpl;
  65   friend IDBFactory;
  66
  67   // TODO: This long-lived raw pointer is very suspicious, in particular as it
  68   // is used in BackgroundDatabaseChild::EnsureDOMObject to reacquire a strong
  69   // reference. What ensures it is kept alive, and why can't we store a strong
  70   // reference here?
  71   IDBFactory* mFactory;
  72
  73  public:
  74   NS_INLINE_DECL_REFCOUNTING(BackgroundFactoryChild, override)
  75
  76   void AssertIsOnOwningThread() const {
  77     NS_ASSERT_OWNINGTHREAD(BackgroundFactoryChild);
  78   }
  79
  80   IDBFactory& GetDOMObject() const {
  81     AssertIsOnOwningThread();
  82     MOZ_ASSERT(mFactory);
  83     return *mFactory;
  84   }
  85
  86   bool SendDeleteMe() = delete;
  87
  88  private:
  89   // Only created by IDBFactory.
  90   explicit BackgroundFactoryChild(IDBFactory& aFactory);
  91
  92   // Only destroyed by mozilla::ipc::BackgroundChildImpl.
  93   ~BackgroundFactoryChild();
  94
  95   void SendDeleteMeInternal();
  96
  97  public:
  98   // IPDL methods are only called by IPDL.
  99   void ActorDestroy(ActorDestroyReason aWhy) override;
 100
 101   PBackgroundIDBFactoryRequestChild* AllocPBackgroundIDBFactoryRequestChild(
 102       const FactoryRequestParams& aParams);
 103
 104   bool DeallocPBackgroundIDBFactoryRequestChild(
 105       PBackgroundIDBFactoryRequestChild* aActor);
 106
 107   PBackgroundIDBDatabaseChild* AllocPBackgroundIDBDatabaseChild(
 108       const DatabaseSpec& aSpec,
 109       PBackgroundIDBFactoryRequestChild* aRequest) const;
 110
 111   bool DeallocPBackgroundIDBDatabaseChild(PBackgroundIDBDatabaseChild* aActor);
 112
 113   mozilla::ipc::IPCResult RecvPBackgroundIDBDatabaseConstructor(
 114       PBackgroundIDBDatabaseChild* aActor, const DatabaseSpec& aSpec,
 115       NotNull<PBackgroundIDBFactoryRequestChild*> aRequest) override;
 116 };
 117
 118 class BackgroundDatabaseChild;
 119
 120 class BackgroundRequestChildBase {
 121  protected:
 122   const NotNull<RefPtr<IDBRequest>> mRequest;
 123
 124  public:
 125   void AssertIsOnOwningThread() const
 126 #ifdef DEBUG
 127       ;
 128 #else
 129   {
 130   }
 131 #endif
 132
 133  protected:
 134   explicit BackgroundRequestChildBase(
 135       MovingNotNull<RefPtr<IDBRequest>> aRequest);
 136
 137   virtual ~BackgroundRequestChildBase();
 138 };
 139
 140 class BackgroundFactoryRequestChild final
 141     : public BackgroundRequestChildBase,
 142       public PBackgroundIDBFactoryRequestChild {
 143   using PersistenceType = mozilla::dom::quota::PersistenceType;
 144
 145   friend IDBFactory;
 146   friend class BackgroundFactoryChild;
 147   friend class BackgroundDatabaseChild;
 148   friend class PermissionRequestChild;
 149   friend class PermissionRequestParent;
 150
 151   const SafeRefPtr<IDBFactory> mFactory;
 152
 153   // Normally when opening of a database is successful, we receive a database
 154   // actor in request response, so we can use it to call ReleaseDOMObject()
 155   // which clears temporary strong reference to IDBDatabase.
 156   // However, when there's an error, we don't receive a database actor and
 157   // IDBRequest::mTransaction is already cleared (must be). So the only way how
 158   // to call ReleaseDOMObject() is to have a back-reference to database actor.
 159   // This creates a weak ref cycle between
 160   // BackgroundFactoryRequestChild (using mDatabaseActor member) and
 161   // BackgroundDatabaseChild actor (using mOpenRequestActor member).
 162   // mDatabaseActor is set in EnsureDOMObject() and cleared in
 163   // ReleaseDOMObject().
 164   BackgroundDatabaseChild* mDatabaseActor;
 165
 166   const uint64_t mRequestedVersion;
 167   const bool mIsDeleteOp;
 168
 169  public:
 170   NotNull<IDBOpenDBRequest*> GetOpenDBRequest() const;
 171
 172  private:
 173   // Only created by IDBFactory.
 174   BackgroundFactoryRequestChild(
 175       SafeRefPtr<IDBFactory> aFactory,
 176       MovingNotNull<RefPtr<IDBOpenDBRequest>> aOpenRequest, bool aIsDeleteOp,
 177       uint64_t aRequestedVersion);
 178
 179   // Only destroyed by BackgroundFactoryChild.
 180   ~BackgroundFactoryRequestChild();
 181
 182   void SetDatabaseActor(BackgroundDatabaseChild* aActor);
 183
 184   void HandleResponse(nsresult aResponse);
 185
 186   void HandleResponse(const OpenDatabaseRequestResponse& aResponse);
 187
 188   void HandleResponse(const DeleteDatabaseRequestResponse& aResponse);
 189
 190  public:
 191   // IPDL methods are only called by IPDL.
 192   void ActorDestroy(ActorDestroyReason aWhy) override;
 193
 194   mozilla::ipc::IPCResult Recv__delete__(
 195       const FactoryRequestResponse& aResponse);
 196
 197   mozilla::ipc::IPCResult RecvPermissionChallenge(
 198       PrincipalInfo&& aPrincipalInfo);
 199
 200   mozilla::ipc::IPCResult RecvBlocked(uint64_t aCurrentVersion);
 201 };
 202
 203 class BackgroundDatabaseChild final : public PBackgroundIDBDatabaseChild {
 204   friend class BackgroundFactoryChild;
 205   friend class BackgroundFactoryRequestChild;
 206   friend IDBDatabase;
 207
 208   UniquePtr<DatabaseSpec> mSpec;
 209   RefPtr<IDBDatabase> mTemporaryStrongDatabase;
 210   BackgroundFactoryRequestChild* mOpenRequestActor;
 211   IDBDatabase* mDatabase;
 212
 213  public:
 214   void AssertIsOnOwningThread() const
 215 #ifdef DEBUG
 216       ;
 217 #else
 218   {
 219   }
 220 #endif
 221
 222   const DatabaseSpec* Spec() const {
 223     AssertIsOnOwningThread();
 224     return mSpec.get();
 225   }
 226
 227   IDBDatabase* GetDOMObject() const {
 228     AssertIsOnOwningThread();
 229     return mDatabase;
 230   }
 231
 232   bool SendDeleteMe() = delete;
 233
 234  private:
 235   // Only constructed by BackgroundFactoryChild.
 236   BackgroundDatabaseChild(const DatabaseSpec& aSpec,
 237                           BackgroundFactoryRequestChild* aOpenRequest);
 238
 239   // Only destroyed by BackgroundFactoryChild.
 240   ~BackgroundDatabaseChild();
 241
 242   void SendDeleteMeInternal();
 243
 244   [[nodiscard]] bool EnsureDOMObject();
 245
 246   void ReleaseDOMObject();
 247
 248  public:
 249   // IPDL methods are only called by IPDL.
 250   void ActorDestroy(ActorDestroyReason aWhy) override;
 251
 252   PBackgroundIDBDatabaseFileChild* AllocPBackgroundIDBDatabaseFileChild(
 253       const IPCBlob& aIPCBlob);
 254
 255   bool DeallocPBackgroundIDBDatabaseFileChild(
 256       PBackgroundIDBDatabaseFileChild* aActor) const;
 257
 258   already_AddRefed<PBackgroundIDBVersionChangeTransactionChild>
 259   AllocPBackgroundIDBVersionChangeTransactionChild(uint64_t aCurrentVersion,
 260                                                    uint64_t aRequestedVersion,
 261                                                    int64_t aNextObjectStoreId,
 262                                                    int64_t aNextIndexId);
 263
 264   mozilla::ipc::IPCResult RecvPBackgroundIDBVersionChangeTransactionConstructor(
 265       PBackgroundIDBVersionChangeTransactionChild* aActor,
 266       const uint64_t& aCurrentVersion, const uint64_t& aRequestedVersion,
 267       const int64_t& aNextObjectStoreId, const int64_t& aNextIndexId) override;
 268
 269   mozilla::ipc::IPCResult RecvVersionChange(uint64_t aOldVersion,
 270                                             Maybe<uint64_t> aNewVersion);
 271
 272   mozilla::ipc::IPCResult RecvInvalidate();
 273
 274   mozilla::ipc::IPCResult RecvCloseAfterInvalidationComplete();
 275 };
 276
 277 class BackgroundVersionChangeTransactionChild;
 278
 279 class BackgroundTransactionBase {
 280   friend class BackgroundVersionChangeTransactionChild;
 281
 282   // mTemporaryStrongTransaction is strong and is only valid until the end of
 283   // NoteComplete() member function or until the NoteActorDestroyed() member
 284   // function is called.
 285   SafeRefPtr<IDBTransaction> mTemporaryStrongTransaction;
 286
 287  protected:
 288   // mTransaction is weak and is valid until the NoteActorDestroyed() member
 289   // function is called.
 290   IDBTransaction* mTransaction = nullptr;
 291
 292  public:
 293 #ifdef DEBUG
 294   virtual void AssertIsOnOwningThread() const = 0;
 295 #else
 296   void AssertIsOnOwningThread() const {}
 297 #endif
 298
 299   IDBTransaction* GetDOMObject() const {
 300     AssertIsOnOwningThread();
 301     return mTransaction;
 302   }
 303
 304  protected:
 305   MOZ_COUNTED_DEFAULT_CTOR(BackgroundTransactionBase);
 306
 307   explicit BackgroundTransactionBase(SafeRefPtr<IDBTransaction> aTransaction);
 308
 309   MOZ_COUNTED_DTOR_VIRTUAL(BackgroundTransactionBase);
 310
 311   void NoteActorDestroyed();
 312
 313   void NoteComplete();
 314
 315  private:
 316   // Only called by BackgroundVersionChangeTransactionChild.
 317   void SetDOMTransaction(SafeRefPtr<IDBTransaction> aTransaction);
 318 };
 319
 320 class BackgroundTransactionChild final : public BackgroundTransactionBase,
 321                                          public PBackgroundIDBTransactionChild {
 322   friend class BackgroundDatabaseChild;
 323   friend IDBDatabase;
 324
 325  public:
 326   NS_INLINE_DECL_REFCOUNTING(BackgroundTransactionChild, override)
 327
 328 #ifdef DEBUG
 329   void AssertIsOnOwningThread() const override;
 330 #endif
 331
 332   void SendDeleteMeInternal();
 333
 334   bool SendDeleteMe() = delete;
 335
 336  private:
 337   // Only created by IDBDatabase.
 338   explicit BackgroundTransactionChild(SafeRefPtr<IDBTransaction> aTransaction);
 339
 340   // Only destroyed by BackgroundDatabaseChild.
 341   ~BackgroundTransactionChild();
 342
 343  public:
 344   // IPDL methods are only called by IPDL.
 345   void ActorDestroy(ActorDestroyReason aWhy) override;
 346
 347   mozilla::ipc::IPCResult RecvComplete(nsresult aResult);
 348
 349   PBackgroundIDBRequestChild* AllocPBackgroundIDBRequestChild(
 350       const RequestParams& aParams);
 351
 352   bool DeallocPBackgroundIDBRequestChild(PBackgroundIDBRequestChild* aActor);
 353
 354   PBackgroundIDBCursorChild* AllocPBackgroundIDBCursorChild(
 355       const OpenCursorParams& aParams);
 356
 357   bool DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor);
 358 };
 359
 360 class BackgroundVersionChangeTransactionChild final
 361     : public BackgroundTransactionBase,
 362       public PBackgroundIDBVersionChangeTransactionChild {
 363   friend class BackgroundDatabaseChild;
 364
 365   IDBOpenDBRequest* mOpenDBRequest;
 366
 367  public:
 368   NS_INLINE_DECL_REFCOUNTING(BackgroundVersionChangeTransactionChild, override)
 369
 370 #ifdef DEBUG
 371   void AssertIsOnOwningThread() const override;
 372 #endif
 373
 374   void SendDeleteMeInternal(bool aFailedConstructor);
 375
 376   bool SendDeleteMe() = delete;
 377
 378  private:
 379   // Only created by BackgroundDatabaseChild.
 380   explicit BackgroundVersionChangeTransactionChild(
 381       IDBOpenDBRequest* aOpenDBRequest);
 382
 383   // Only destroyed by BackgroundDatabaseChild.
 384   ~BackgroundVersionChangeTransactionChild();
 385
 386   // Only called by BackgroundDatabaseChild.
 387   using BackgroundTransactionBase::SetDOMTransaction;
 388
 389  public:
 390   // IPDL methods are only called by IPDL.
 391   void ActorDestroy(ActorDestroyReason aWhy) override;
 392
 393   mozilla::ipc::IPCResult RecvComplete(nsresult aResult);
 394
 395   PBackgroundIDBRequestChild* AllocPBackgroundIDBRequestChild(
 396       const RequestParams& aParams);
 397
 398   bool DeallocPBackgroundIDBRequestChild(PBackgroundIDBRequestChild* aActor);
 399
 400   PBackgroundIDBCursorChild* AllocPBackgroundIDBCursorChild(
 401       const OpenCursorParams& aParams);
 402
 403   bool DeallocPBackgroundIDBCursorChild(PBackgroundIDBCursorChild* aActor);
 404 };
 405
 406 class BackgroundRequestChild final : public BackgroundRequestChildBase,
 407                                      public PBackgroundIDBRequestChild {
 408   friend class BackgroundTransactionChild;
 409   friend class BackgroundVersionChangeTransactionChild;
 410   friend struct CloneInfo;
 411   friend IDBTransaction;
 412
 413   class PreprocessHelper;
 414
 415   SafeRefPtr<IDBTransaction> mTransaction;
 416   nsTArray<CloneInfo> mCloneInfos;
 417   uint32_t mRunningPreprocessHelpers;
 418   uint32_t mCurrentCloneDataIndex;
 419   nsresult mPreprocessResultCode;
 420   bool mGetAll;
 421
 422  private:
 423   // Only created by IDBTransaction.
 424   explicit BackgroundRequestChild(MovingNotNull<RefPtr<IDBRequest>> aRequest);
 425
 426   // Only destroyed by BackgroundTransactionChild or
 427   // BackgroundVersionChangeTransactionChild.
 428   ~BackgroundRequestChild();
 429
 430   void MaybeSendContinue();
 431
 432   void OnPreprocessFinished(uint32_t aCloneDataIndex,
 433                             UniquePtr<JSStructuredCloneData> aCloneData);
 434
 435   void OnPreprocessFailed(uint32_t aCloneDataIndex, nsresult aErrorCode);
 436
 437   UniquePtr<JSStructuredCloneData> GetNextCloneData();
 438
 439   void HandleResponse(nsresult aResponse);
 440
 441   void HandleResponse(const Key& aResponse);
 442
 443   void HandleResponse(const nsTArray<Key>& aResponse);
 444
 445   void HandleResponse(SerializedStructuredCloneReadInfo&& aResponse);
 446
 447   void HandleResponse(nsTArray<SerializedStructuredCloneReadInfo>&& aResponse);
 448
 449   void HandleResponse(JS::Handle<JS::Value> aResponse);
 450
 451   void HandleResponse(uint64_t aResponse);
 452
 453   nsresult HandlePreprocess(const PreprocessInfo& aPreprocessInfo);
 454
 455   nsresult HandlePreprocess(const nsTArray<PreprocessInfo>& aPreprocessInfos);
 456
 457   nsresult HandlePreprocessInternal(
 458       const nsTArray<PreprocessInfo>& aPreprocessInfos);
 459
 460   SafeRefPtr<IDBTransaction> AcquireTransaction() const {
 461     return mTransaction.clonePtr();
 462   }
 463
 464  public:
 465   // IPDL methods are only called by IPDL.
 466   void ActorDestroy(ActorDestroyReason aWhy) override;
 467
 468   mozilla::ipc::IPCResult Recv__delete__(RequestResponse&& aResponse);
 469
 470   mozilla::ipc::IPCResult RecvPreprocess(const PreprocessParams& aParams);
 471 };
 472
 473 struct CloneInfo {
 474   RefPtr<BackgroundRequestChild::PreprocessHelper> mPreprocessHelper;
 475   UniquePtr<JSStructuredCloneData> mCloneData;
 476 };
 477
 478 class BackgroundCursorChildBase
 479     : public PBackgroundIDBCursorChild,
 480       public SafeRefCounted<BackgroundCursorChildBase> {
 481  private:
 482   NS_DECL_OWNINGTHREAD
 483
 484  public:
 485   MOZ_DECLARE_REFCOUNTED_TYPENAME(
 486       mozilla::dom::indexedDB::BackgroundCursorChildBase)
 487   MOZ_INLINE_DECL_SAFEREFCOUNTING_INHERITED(BackgroundCursorChildBase,
 488                                             SafeRefCounted)
 489
 490  protected:
 491   ~BackgroundCursorChildBase();
 492
 493   InitializedOnce<const NotNull<IDBRequest*>> mRequest;
 494   Maybe<IDBTransaction&> mTransaction;
 495
 496   // These are only set while a request is in progress.
 497   RefPtr<IDBRequest> mStrongRequest;
 498   RefPtr<IDBCursor> mStrongCursor;
 499
 500   const Direction mDirection;
 501
 502   BackgroundCursorChildBase(NotNull<IDBRequest*> aRequest,
 503                             Direction aDirection);
 504
 505   void HandleResponse(nsresult aResponse);
 506
 507  public:
 508   void AssertIsOnOwningThread() const {
 509     NS_ASSERT_OWNINGTHREAD(BackgroundCursorChildBase);
 510   }
 511
 512   MovingNotNull<RefPtr<IDBRequest>> AcquireRequest() const;
 513
 514   NotNull<IDBRequest*> GetRequest() const {
 515     AssertIsOnOwningThread();
 516
 517     return *mRequest;
 518   }
 519
 520   Direction GetDirection() const {
 521     AssertIsOnOwningThread();
 522
 523     return mDirection;
 524   }
 525
 526   virtual void SendDeleteMeInternal() = 0;
 527
 528   virtual mozilla::ipc::IPCResult RecvResponse(CursorResponse&& aResponse) = 0;
 529 };
 530
 531 template <IDBCursorType CursorType>
 532 class BackgroundCursorChild final : public BackgroundCursorChildBase {
 533  public:
 534   using SourceType = CursorSourceType<CursorType>;
 535   using ResponseType = typename CursorTypeTraits<CursorType>::ResponseType;
 536
 537  private:
 538   friend class BackgroundTransactionChild;
 539   friend class BackgroundVersionChangeTransactionChild;
 540
 541   InitializedOnce<const NotNull<SourceType*>> mSource;
 542   IDBCursorImpl<CursorType>* mCursor;
 543
 544   std::deque<CursorData<CursorType>> mCachedResponses, mDelayedResponses;
 545   bool mInFlightResponseInvalidationNeeded;
 546
 547  public:
 548   BackgroundCursorChild(NotNull<IDBRequest*> aRequest, SourceType* aSource,
 549                         Direction aDirection);
 550
 551   void SendContinueInternal(const CursorRequestParams& aParams,
 552                             const CursorData<CursorType>& aCurrentData);
 553
 554   void InvalidateCachedResponses();
 555
 556   template <typename Condition>
 557   void DiscardCachedResponses(const Condition& aConditionFunc);
 558
 559   SourceType* GetSource() const {
 560     AssertIsOnOwningThread();
 561
 562     return *mSource;
 563   }
 564
 565   void SendDeleteMeInternal() final;
 566
 567  private:
 568   // Only destroyed by BackgroundTransactionChild or
 569   // BackgroundVersionChangeTransactionChild.
 570   ~BackgroundCursorChild();
 571
 572   void CompleteContinueRequestFromCache();
 573
 574   using BackgroundCursorChildBase::HandleResponse;
 575
 576   void HandleResponse(const void_t& aResponse);
 577
 578   void HandleResponse(nsTArray<ResponseType>&& aResponses);
 579
 580   template <typename Func>
 581   void HandleMultipleCursorResponses(nsTArray<ResponseType>&& aResponses,
 582                                      const Func& aHandleRecord);
 583
 584   template <typename... Args>
 585   [[nodiscard]] RefPtr<IDBCursor> HandleIndividualCursorResponse(
 586       bool aUseAsCurrentResult, Args&&... aArgs);
 587
 588   SafeRefPtr<BackgroundCursorChild> SafeRefPtrFromThis();
 589
 590  public:
 591   // IPDL methods are only called by IPDL.
 592   void ActorDestroy(ActorDestroyReason aWhy) override;
 593
 594   mozilla::ipc::IPCResult RecvResponse(CursorResponse&& aResponse) override;
 595
 596   // Force callers to use SendContinueInternal.
 597   bool SendContinue(const CursorRequestParams& aParams, const Key& aCurrentKey,
 598                     const Key& aCurrentObjectStoreKey) = delete;
 599
 600   bool SendDeleteMe() = delete;
 601 };
 602
 603 class BackgroundUtilsChild final : public PBackgroundIndexedDBUtilsChild {
 604   friend class mozilla::ipc::BackgroundChildImpl;
 605   friend IndexedDatabaseManager;
 606
 607   IndexedDatabaseManager* mManager;
 608
 609   NS_DECL_OWNINGTHREAD
 610
 611  public:
 612   void AssertIsOnOwningThread() const {
 613     NS_ASSERT_OWNINGTHREAD(BackgroundUtilsChild);
 614   }
 615
 616   bool SendDeleteMe() = delete;
 617
 618  private:
 619   // Only created by IndexedDatabaseManager.
 620   explicit BackgroundUtilsChild(IndexedDatabaseManager* aManager);
 621
 622   // Only destroyed by mozilla::ipc::BackgroundChildImpl.
 623   ~BackgroundUtilsChild();
 624
 625   void SendDeleteMeInternal();
 626
 627  public:
 628   // IPDL methods are only called by IPDL.
 629   void ActorDestroy(ActorDestroyReason aWhy) override;
 630 };
 631
 632 }  // namespace mozilla::dom::indexedDB
 633
 634 #endif  // mozilla_dom_indexeddb_actorschild_h__