dom/indexedDB/IDBCursor.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_idbcursor_h__
   8 #define mozilla_dom_idbcursor_h__
   9
  10 #include "IDBCursorType.h"
  11 #include "IndexedDatabase.h"
  12 #include "js/RootingAPI.h"
  13 #include "mozilla/Attributes.h"
  14 #include "mozilla/dom/IDBCursorBinding.h"
  15 #include "mozilla/dom/IDBTransaction.h"
  16 #include "mozilla/dom/indexedDB/Key.h"
  17 #include "mozilla/dom/quota/CheckedUnsafePtr.h"
  18 #include "mozilla/InitializedOnce.h"
  19 #include "nsCycleCollectionParticipant.h"
  20 #include "nsWrapperCache.h"
  21
  22 class nsIGlobalObject;
  23
  24 namespace mozilla {
  25
  26 class ErrorResult;
  27
  28 namespace dom {
  29
  30 class IDBIndex;
  31 class IDBObjectStore;
  32 class IDBRequest;
  33 class OwningIDBObjectStoreOrIDBIndex;
  34
  35 class IDBObjectStoreCursor;
  36 class IDBObjectStoreKeyCursor;
  37 class IDBIndexCursor;
  38 class IDBIndexKeyCursor;
  39
  40 namespace indexedDB {
  41 class BackgroundCursorChildBase;
  42 template <IDBCursorType CursorType>
  43 class BackgroundCursorChild;
  44 }  // namespace indexedDB
  45
  46 class IDBCursor : public nsISupports, public nsWrapperCache {
  47  public:
  48   using Key = indexedDB::Key;
  49   using StructuredCloneReadInfoChild = indexedDB::StructuredCloneReadInfoChild;
  50
  51   using Direction = IDBCursorDirection;
  52   using Type = IDBCursorType;
  53
  54  protected:
  55   InitializedOnce<const NotNull<indexedDB::BackgroundCursorChildBase*>>
  56       mBackgroundActor;
  57
  58   // TODO: mRequest could be made const if Bug 1575173 is resolved. It is
  59   // initialized in the constructor and never modified/cleared.
  60   RefPtr<IDBRequest> mRequest;
  61
  62   // Sub-classes' mSource will hold this alive.
  63   CheckedUnsafePtr<IDBTransaction> mTransaction;
  64
  65  protected:
  66   // These are cycle-collected!
  67   JS::Heap<JS::Value> mCachedKey;
  68   JS::Heap<JS::Value> mCachedPrimaryKey;
  69   JS::Heap<JS::Value> mCachedValue;
  70
  71   const Direction mDirection;
  72
  73   bool mHaveCachedKey : 1;
  74   bool mHaveCachedPrimaryKey : 1;
  75   bool mHaveCachedValue : 1;
  76   bool mRooted : 1;
  77   bool mContinueCalled : 1;
  78   bool mHaveValue : 1;
  79
  80  public:
  81   [[nodiscard]] static RefPtr<IDBObjectStoreCursor> Create(
  82       indexedDB::BackgroundCursorChild<Type::ObjectStore>* aBackgroundActor,
  83       Key aKey, StructuredCloneReadInfoChild&& aCloneInfo);
  84
  85   [[nodiscard]] static RefPtr<IDBObjectStoreKeyCursor> Create(
  86       indexedDB::BackgroundCursorChild<Type::ObjectStoreKey>* aBackgroundActor,
  87       Key aKey);
  88
  89   [[nodiscard]] static RefPtr<IDBIndexCursor> Create(
  90       indexedDB::BackgroundCursorChild<Type::Index>* aBackgroundActor, Key aKey,
  91       Key aSortKey, Key aPrimaryKey, StructuredCloneReadInfoChild&& aCloneInfo);
  92
  93   [[nodiscard]] static RefPtr<IDBIndexKeyCursor> Create(
  94       indexedDB::BackgroundCursorChild<Type::IndexKey>* aBackgroundActor,
  95       Key aKey, Key aSortKey, Key aPrimaryKey);
  96
  97   void AssertIsOnOwningThread() const
  98 #ifdef DEBUG
  99       ;
 100 #else
 101   {
 102   }
 103 #endif
 104
 105   nsIGlobalObject* GetParentObject() const;
 106
 107   // XXX: The virtual methods that are used by the DOM binding could be removed
 108   // on the base class, if we provided a non-polymorphic wrapper instead, which
 109   // uses a custom dispatch to the actual implementation type. Don't know if
 110   // this is worth it.
 111
 112   virtual void GetSource(OwningIDBObjectStoreOrIDBIndex& aSource) const = 0;
 113
 114   IDBCursorDirection GetDirection() const;
 115
 116   RefPtr<IDBRequest> Request() const;
 117
 118   virtual void GetKey(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 119                       ErrorResult& aRv) = 0;
 120
 121   virtual void GetPrimaryKey(JSContext* aCx,
 122                              JS::MutableHandle<JS::Value> aResult,
 123                              ErrorResult& aRv) = 0;
 124
 125   // XXX: We could move this to a sub-class, since this is only present on
 126   // IDBCursorWithValue.
 127   virtual void GetValue(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 128                         ErrorResult& aRv) = 0;
 129
 130   virtual void Continue(JSContext* aCx, JS::Handle<JS::Value> aKey,
 131                         ErrorResult& aRv) = 0;
 132
 133   virtual void ContinuePrimaryKey(JSContext* aCx, JS::Handle<JS::Value> aKey,
 134                                   JS::Handle<JS::Value> aPrimaryKey,
 135                                   ErrorResult& aRv) = 0;
 136
 137   virtual void Advance(uint32_t aCount, ErrorResult& aRv) = 0;
 138
 139   [[nodiscard]] virtual RefPtr<IDBRequest> Update(JSContext* aCx,
 140                                                   JS::Handle<JS::Value> aValue,
 141                                                   ErrorResult& aRv) = 0;
 142
 143   [[nodiscard]] virtual RefPtr<IDBRequest> Delete(JSContext* aCx,
 144                                                   ErrorResult& aRv) = 0;
 145
 146   void ClearBackgroundActor() {
 147     AssertIsOnOwningThread();
 148
 149     mBackgroundActor.destroy();
 150   }
 151
 152   virtual void InvalidateCachedResponses() = 0;
 153
 154   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 155   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(IDBCursor)
 156
 157  protected:
 158   IDBCursor(indexedDB::BackgroundCursorChildBase* aBackgroundActor);
 159
 160   // TODO: Check if we can remove virtual by changing cycle collection.
 161   virtual ~IDBCursor() = default;
 162
 163   void ResetBase();
 164 };
 165
 166 template <IDBCursor::Type CursorType>
 167 class IDBTypedCursor : public IDBCursor {
 168  public:
 169   template <typename... DataArgs>
 170   explicit IDBTypedCursor(
 171       indexedDB::BackgroundCursorChild<CursorType>* aBackgroundActor,
 172       DataArgs&&... aDataArgs);
 173
 174   static constexpr Type GetType() { return CursorType; }
 175
 176   // Checks if this is a locale aware cursor (ie. the index's sortKey is unset)
 177   bool IsLocaleAware() const;
 178
 179   void GetSource(OwningIDBObjectStoreOrIDBIndex& aSource) const final;
 180
 181   void GetKey(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 182               ErrorResult& aRv) final;
 183
 184   void GetPrimaryKey(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 185                      ErrorResult& aRv) final;
 186
 187   void GetValue(JSContext* aCx, JS::MutableHandle<JS::Value> aResult,
 188                 ErrorResult& aRv) final;
 189
 190   void Continue(JSContext* aCx, JS::Handle<JS::Value> aKey,
 191                 ErrorResult& aRv) final;
 192
 193   void ContinuePrimaryKey(JSContext* aCx, JS::Handle<JS::Value> aKey,
 194                           JS::Handle<JS::Value> aPrimaryKey,
 195                           ErrorResult& aRv) final;
 196
 197   void Advance(uint32_t aCount, ErrorResult& aRv) final;
 198
 199   [[nodiscard]] RefPtr<IDBRequest> Update(JSContext* aCx,
 200                                           JS::Handle<JS::Value> aValue,
 201                                           ErrorResult& aRv) final;
 202
 203   [[nodiscard]] RefPtr<IDBRequest> Delete(JSContext* aCx,
 204                                           ErrorResult& aRv) final;
 205
 206   // nsWrapperCache
 207   JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
 208
 209   void InvalidateCachedResponses() final;
 210
 211   void Reset();
 212
 213   void Reset(CursorData<CursorType>&& aCursorData);
 214
 215  private:
 216   static constexpr bool IsObjectStoreCursor =
 217       CursorTypeTraits<CursorType>::IsObjectStoreCursor;
 218   static constexpr bool IsKeyOnlyCursor =
 219       CursorTypeTraits<CursorType>::IsKeyOnlyCursor;
 220
 221   CursorSourceType<CursorType>& GetSourceRef() const {
 222     MOZ_ASSERT(mSource);
 223     return *mSource;
 224   }
 225
 226   IDBObjectStore& GetSourceObjectStoreRef() const {
 227     if constexpr (IsObjectStoreCursor) {
 228       return GetSourceRef();
 229     } else {
 230       MOZ_ASSERT(!GetSourceRef().IsDeleted());
 231
 232       auto res = GetSourceRef().ObjectStore();
 233       MOZ_ASSERT(res);
 234       return *res;
 235     }
 236   }
 237
 238   indexedDB::BackgroundCursorChild<CursorType>& GetTypedBackgroundActorRef()
 239       const {
 240     // We can safely downcast to BackgroundCursorChild<CursorType>*, since we
 241     // initialized that in the constructor from that type. We just want to avoid
 242     // having a second typed field.
 243     return *static_cast<indexedDB::BackgroundCursorChild<CursorType>*>(
 244         mBackgroundActor->get());
 245   }
 246
 247   bool IsSourceDeleted() const;
 248
 249  protected:
 250   virtual ~IDBTypedCursor() override;
 251
 252   void DropJSObjects();
 253
 254   CursorData<CursorType> mData;
 255
 256   // TODO: mSource could be made const if Bug 1575173 is resolved. It is
 257   // initialized in the constructor and never modified/cleared.
 258   RefPtr<CursorSourceType<CursorType>> mSource;
 259 };
 260
 261 // The subclasses defined by this macro are only needed to be able to use the
 262 // cycle collector macros, which do not support templates. If spelled out, the
 263 // cycle collection could be implemented directly on IDBTypedCursor, and these
 264 // classes were not needed.
 265 #define CONCRETE_IDBCURSOR_SUBCLASS(_subclassName, _cursorType)        \
 266   class _subclassName final : public IDBTypedCursor<_cursorType> {     \
 267    public:                                                             \
 268     NS_DECL_ISUPPORTS_INHERITED                                        \
 269     NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(_subclassName, IDBCursor) \
 270                                                                        \
 271     using IDBTypedCursor<_cursorType>::IDBTypedCursor;                 \
 272                                                                        \
 273    private:                                                            \
 274     ~_subclassName() final = default;                                  \
 275   };
 276
 277 CONCRETE_IDBCURSOR_SUBCLASS(IDBObjectStoreCursor, IDBCursor::Type::ObjectStore)
 278 CONCRETE_IDBCURSOR_SUBCLASS(IDBObjectStoreKeyCursor,
 279                             IDBCursor::Type::ObjectStoreKey)
 280 CONCRETE_IDBCURSOR_SUBCLASS(IDBIndexCursor, IDBCursor::Type::Index)
 281 CONCRETE_IDBCURSOR_SUBCLASS(IDBIndexKeyCursor, IDBCursor::Type::IndexKey)
 282
 283 template <IDBCursor::Type CursorType>
 284 using IDBCursorImpl = typename CursorTypeTraits<CursorType>::Type;
 285
 286 }  // namespace dom
 287 }  // namespace mozilla
 288
 289 #endif  // mozilla_dom_idbcursor_h__