dom/indexedDB/IDBRequest.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_idbrequest_h__
   8 #define mozilla_dom_idbrequest_h__
   9
  10 #include "js/RootingAPI.h"
  11 #include "mozilla/Attributes.h"
  12 #include "mozilla/EventForwards.h"
  13 #include "mozilla/SourceLocation.h"
  14 #include "mozilla/dom/DOMException.h"
  15 #include "mozilla/dom/IDBRequestBinding.h"
  16 #include "mozilla/dom/ScriptSettings.h"
  17 #include "mozilla/DOMEventTargetHelper.h"
  18 #include "mozilla/HoldDropJSObjects.h"
  19 #include "nsCycleCollectionParticipant.h"
  20 #include "ReportInternalError.h"
  21 #include "SafeRefPtr.h"
  22
  23 #define PRIVATE_IDBREQUEST_IID                       \
  24   {                                                  \
  25     0xe68901e5, 0x1d50, 0x4ee9, {                    \
  26       0xaf, 0x49, 0x90, 0x99, 0x4a, 0xff, 0xc8, 0x39 \
  27     }                                                \
  28   }
  29
  30 class nsIGlobalObject;
  31
  32 namespace mozilla {
  33
  34 class ErrorResult;
  35
  36 namespace dom {
  37
  38 class IDBCursor;
  39 class IDBDatabase;
  40 class IDBFactory;
  41 class IDBIndex;
  42 class IDBObjectStore;
  43 class IDBTransaction;
  44 template <typename>
  45 struct Nullable;
  46 class OwningIDBObjectStoreOrIDBIndexOrIDBCursor;
  47 class StrongWorkerRef;
  48
  49 namespace detail {
  50 // This class holds the IID for use with NS_GET_IID.
  51 class PrivateIDBRequest {
  52  public:
  53   NS_DECLARE_STATIC_IID_ACCESSOR(PRIVATE_IDBREQUEST_IID)
  54 };
  55
  56 NS_DEFINE_STATIC_IID_ACCESSOR(PrivateIDBRequest, PRIVATE_IDBREQUEST_IID)
  57
  58 }  // namespace detail
  59
  60 class IDBRequest : public DOMEventTargetHelper {
  61  protected:
  62   // mSourceAsObjectStore and mSourceAsIndex are exclusive and one must always
  63   // be set. mSourceAsCursor is sometimes set also.
  64   RefPtr<IDBObjectStore> mSourceAsObjectStore;
  65   RefPtr<IDBIndex> mSourceAsIndex;
  66   RefPtr<IDBCursor> mSourceAsCursor;
  67
  68   SafeRefPtr<IDBTransaction> mTransaction;
  69
  70   JS::Heap<JS::Value> mResultVal;
  71   RefPtr<DOMException> mError;
  72
  73   JSCallingLocation mCallerLocation;
  74   uint64_t mLoggingSerialNumber;
  75   nsresult mErrorCode;
  76   bool mHaveResultOrErrorCode;
  77
  78  public:
  79   [[nodiscard]] static MovingNotNull<RefPtr<IDBRequest>> Create(
  80       JSContext* aCx, IDBDatabase* aDatabase,
  81       SafeRefPtr<IDBTransaction> aTransaction);
  82
  83   [[nodiscard]] static MovingNotNull<RefPtr<IDBRequest>> Create(
  84       JSContext* aCx, IDBObjectStore* aSource, IDBDatabase* aDatabase,
  85       SafeRefPtr<IDBTransaction> aTransaction);
  86
  87   [[nodiscard]] static MovingNotNull<RefPtr<IDBRequest>> Create(
  88       JSContext* aCx, IDBIndex* aSource, IDBDatabase* aDatabase,
  89       SafeRefPtr<IDBTransaction> aTransaction);
  90
  91   static uint64_t NextSerialNumber();
  92
  93   // EventTarget
  94   void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
  95
  96   void GetSource(
  97       Nullable<OwningIDBObjectStoreOrIDBIndexOrIDBCursor>& aSource) const;
  98
  99   void Reset();
 100
 101   template <typename ResultCallback>
 102   void SetResult(const ResultCallback& aCallback) {
 103     AssertIsOnOwningThread();
 104     MOZ_ASSERT(!mHaveResultOrErrorCode);
 105     MOZ_ASSERT(mResultVal.isUndefined());
 106     MOZ_ASSERT(!mError);
 107
 108     // Already disconnected from the owner.
 109     if (!GetOwnerGlobal()) {
 110       SetError(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 111       return;
 112     }
 113
 114     // See this global is still valid.
 115     if (NS_WARN_IF(NS_FAILED(CheckCurrentGlobalCorrectness()))) {
 116       SetError(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 117       return;
 118     }
 119
 120     AutoJSAPI autoJS;
 121     if (!autoJS.Init(GetOwnerGlobal())) {
 122       IDB_WARNING("Failed to initialize AutoJSAPI!");
 123       SetError(NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 124       return;
 125     }
 126
 127     JSContext* cx = autoJS.cx();
 128
 129     JS::Rooted<JS::Value> result(cx);
 130     nsresult rv = aCallback(cx, &result);
 131     if (NS_WARN_IF(NS_FAILED(rv))) {
 132       // This can only fail if the structured clone contains a mutable file
 133       // and the child is not in the main thread and main process.
 134       // In that case CreateAndWrapMutableFile() returns false which shows up
 135       // as NS_ERROR_DOM_DATA_CLONE_ERR here.
 136       MOZ_ASSERT(rv == NS_ERROR_DOM_DATA_CLONE_ERR);
 137
 138       // We are not setting a result or an error object here since we want to
 139       // throw an exception when the 'result' property is being touched.
 140       return;
 141     }
 142
 143     mError = nullptr;
 144
 145     mResultVal = result;
 146     mozilla::HoldJSObjects(this);
 147
 148     mHaveResultOrErrorCode = true;
 149   }
 150
 151   void SetError(nsresult aRv);
 152
 153   nsresult GetErrorCode() const
 154 #ifdef DEBUG
 155       ;
 156 #else
 157   {
 158     return mErrorCode;
 159   }
 160 #endif
 161
 162   DOMException* GetErrorAfterResult() const
 163 #ifdef DEBUG
 164       ;
 165 #else
 166   {
 167     return mError;
 168   }
 169 #endif
 170
 171   DOMException* GetError(ErrorResult& aRv);
 172
 173   const JSCallingLocation& GetCallerLocation() const { return mCallerLocation; }
 174
 175   bool IsPending() const { return !mHaveResultOrErrorCode; }
 176
 177   uint64_t LoggingSerialNumber() const {
 178     AssertIsOnOwningThread();
 179
 180     return mLoggingSerialNumber;
 181   }
 182
 183   void SetLoggingSerialNumber(uint64_t aLoggingSerialNumber);
 184
 185   nsIGlobalObject* GetParentObject() const { return GetOwnerGlobal(); }
 186
 187   void GetResult(JS::MutableHandle<JS::Value> aResult, ErrorResult& aRv) const;
 188
 189   void GetResult(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 190                  ErrorResult& aRv) const {
 191     GetResult(aResult, aRv);
 192   }
 193
 194   Maybe<IDBTransaction&> MaybeTransactionRef() const {
 195     AssertIsOnOwningThread();
 196
 197     return mTransaction.maybeDeref();
 198   }
 199
 200   IDBTransaction& MutableTransactionRef() const {
 201     AssertIsOnOwningThread();
 202
 203     return *mTransaction;
 204   }
 205
 206   SafeRefPtr<IDBTransaction> AcquireTransaction() const {
 207     AssertIsOnOwningThread();
 208
 209     return mTransaction.clonePtr();
 210   }
 211
 212   // For WebIDL binding.
 213   RefPtr<IDBTransaction> GetTransaction() const {
 214     AssertIsOnOwningThread();
 215
 216     return AsRefPtr(mTransaction.clonePtr());
 217   }
 218
 219   IDBRequestReadyState ReadyState() const;
 220
 221   void SetSource(IDBCursor* aSource);
 222
 223   IMPL_EVENT_HANDLER(success);
 224   IMPL_EVENT_HANDLER(error);
 225
 226   void AssertIsOnOwningThread() const { NS_ASSERT_OWNINGTHREAD(IDBRequest); }
 227
 228   NS_DECL_ISUPPORTS_INHERITED
 229   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(IDBRequest,
 230                                                          DOMEventTargetHelper)
 231
 232   // nsWrapperCache
 233   virtual JSObject* WrapObject(JSContext* aCx,
 234                                JS::Handle<JSObject*> aGivenProto) override;
 235
 236  protected:
 237   explicit IDBRequest(IDBDatabase* aDatabase);
 238   explicit IDBRequest(nsIGlobalObject* aGlobal);
 239   ~IDBRequest();
 240
 241   void InitMembers();
 242
 243   void ConstructResult();
 244 };
 245
 246 class IDBOpenDBRequest final : public IDBRequest {
 247   // Only touched on the owning thread.
 248   SafeRefPtr<IDBFactory> mFactory;
 249
 250   RefPtr<StrongWorkerRef> mWorkerRef;
 251
 252   bool mIncreasedActiveDatabaseCount;
 253
 254  public:
 255   [[nodiscard]] static RefPtr<IDBOpenDBRequest> Create(
 256       JSContext* aCx, SafeRefPtr<IDBFactory> aFactory,
 257       nsIGlobalObject* aGlobal);
 258
 259   void SetTransaction(SafeRefPtr<IDBTransaction> aTransaction);
 260
 261   void DispatchNonTransactionError(nsresult aErrorCode);
 262
 263   void NoteComplete();
 264
 265   // EventTarget
 266   IMPL_EVENT_HANDLER(blocked);
 267   IMPL_EVENT_HANDLER(upgradeneeded);
 268
 269   NS_DECL_ISUPPORTS_INHERITED
 270   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(IDBOpenDBRequest, IDBRequest)
 271
 272   // nsWrapperCache
 273   virtual JSObject* WrapObject(JSContext* aCx,
 274                                JS::Handle<JSObject*> aGivenProto) override;
 275
 276  private:
 277   IDBOpenDBRequest(SafeRefPtr<IDBFactory> aFactory, nsIGlobalObject* aGlobal);
 278
 279   ~IDBOpenDBRequest();
 280
 281   void IncreaseActiveDatabaseCount();
 282
 283   void MaybeDecreaseActiveDatabaseCount();
 284 };
 285
 286 }  // namespace dom
 287 }  // namespace mozilla
 288
 289 #endif  // mozilla_dom_idbrequest_h__