dom/indexedDB/IDBTransaction.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_indexeddb_idbtransaction_h__
   8 #define mozilla_dom_indexeddb_idbtransaction_h__
   9
  10 #include "mozilla/Attributes.h"
  11 #include "mozilla/dom/indexedDB/IndexedDatabase.h"
  12
  13 #include "mozIStorageConnection.h"
  14 #include "mozIStorageStatement.h"
  15 #include "mozIStorageFunction.h"
  16 #include "mozilla/dom/DOMError.h"
  17 #include "nsIRunnable.h"
  18
  19 #include "nsAutoPtr.h"
  20 #include "nsClassHashtable.h"
  21 #include "nsHashKeys.h"
  22 #include "nsInterfaceHashtable.h"
  23 #include "nsRefPtrHashtable.h"
  24
  25 #include "mozilla/dom/IDBTransactionBinding.h"
  26 #include "mozilla/dom/indexedDB/IDBDatabase.h"
  27 #include "mozilla/dom/indexedDB/IDBWrapperCache.h"
  28 #include "mozilla/dom/indexedDB/FileInfo.h"
  29
  30 class nsIThread;
  31 class nsPIDOMWindow;
  32
  33 namespace mozilla {
  34 class EventChainPreVisitor;
  35 } // namespace mozilla
  36
  37 BEGIN_INDEXEDDB_NAMESPACE
  38
  39 class AsyncConnectionHelper;
  40 class CommitHelper;
  41 class IDBRequest;
  42 class IndexedDBDatabaseChild;
  43 class IndexedDBTransactionChild;
  44 class IndexedDBTransactionParent;
  45 struct ObjectStoreInfo;
  46 class TransactionThreadPool;
  47 class UpdateRefcountFunction;
  48
  49 class IDBTransactionListener
  50 {
  51 public:
  52   NS_IMETHOD_(MozExternalRefCountType) AddRef() = 0;
  53   NS_IMETHOD_(MozExternalRefCountType) Release() = 0;
  54
  55   // Called just before dispatching the final events on the transaction.
  56   virtual nsresult NotifyTransactionPreComplete(IDBTransaction* aTransaction) = 0;
  57   // Called just after dispatching the final events on the transaction.
  58   virtual nsresult NotifyTransactionPostComplete(IDBTransaction* aTransaction) = 0;
  59 };
  60
  61 class IDBTransaction : public IDBWrapperCache,
  62                        public nsIRunnable
  63 {
  64   friend class AsyncConnectionHelper;
  65   friend class CommitHelper;
  66   friend class IndexedDBDatabaseChild;
  67   friend class ThreadObserver;
  68   friend class TransactionThreadPool;
  69
  70 public:
  71   NS_DECL_ISUPPORTS_INHERITED
  72   NS_DECL_NSIRUNNABLE
  73
  74   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(IDBTransaction, IDBWrapperCache)
  75
  76   enum Mode
  77   {
  78     READ_ONLY = 0,
  79     READ_WRITE,
  80     VERSION_CHANGE,
  81
  82     // Only needed for IPC serialization helper, should never be used in code.
  83     MODE_INVALID
  84   };
  85
  86   enum ReadyState
  87   {
  88     INITIAL = 0,
  89     LOADING,
  90     COMMITTING,
  91     DONE
  92   };
  93
  94   static already_AddRefed<IDBTransaction>
  95   Create(IDBDatabase* aDatabase,
  96          const Sequence<nsString>& aObjectStoreNames,
  97          Mode aMode,
  98          bool aDispatchDelayed)
  99   {
 100     return CreateInternal(aDatabase, aObjectStoreNames, aMode, aDispatchDelayed,
 101                           false);
 102   }
 103
 104   // nsIDOMEventTarget
 105   virtual nsresult PreHandleEvent(EventChainPreVisitor& aVisitor) MOZ_OVERRIDE;
 106
 107   void OnNewRequest();
 108   void OnRequestFinished();
 109   void OnRequestDisconnected();
 110
 111   void RemoveObjectStore(const nsAString& aName);
 112
 113   void SetTransactionListener(IDBTransactionListener* aListener);
 114
 115   bool StartSavepoint();
 116   nsresult ReleaseSavepoint();
 117   void RollbackSavepoint();
 118
 119   // Only meant to be called on mStorageThread!
 120   nsresult GetOrCreateConnection(mozIStorageConnection** aConnection);
 121
 122   already_AddRefed<mozIStorageStatement>
 123   GetCachedStatement(const nsACString& aQuery);
 124
 125   template<int N>
 126   already_AddRefed<mozIStorageStatement>
 127   GetCachedStatement(const char (&aQuery)[N])
 128   {
 129     return GetCachedStatement(NS_LITERAL_CSTRING(aQuery));
 130   }
 131
 132   bool IsOpen() const;
 133
 134   bool IsFinished() const
 135   {
 136     return mReadyState > LOADING;
 137   }
 138
 139   bool IsWriteAllowed() const
 140   {
 141     return mMode == READ_WRITE || mMode == VERSION_CHANGE;
 142   }
 143
 144   bool IsAborted() const
 145   {
 146     return NS_FAILED(mAbortCode);
 147   }
 148
 149   // 'Get' prefix is to avoid name collisions with the enum
 150   Mode GetMode()
 151   {
 152     return mMode;
 153   }
 154
 155   IDBDatabase* Database()
 156   {
 157     NS_ASSERTION(mDatabase, "This should never be null!");
 158     return mDatabase;
 159   }
 160
 161   DatabaseInfo* DBInfo() const
 162   {
 163     return mDatabaseInfo;
 164   }
 165
 166   already_AddRefed<IDBObjectStore>
 167   GetOrCreateObjectStore(const nsAString& aName,
 168                          ObjectStoreInfo* aObjectStoreInfo,
 169                          bool aCreating);
 170
 171   already_AddRefed<FileInfo> GetFileInfo(nsIDOMBlob* aBlob);
 172   void AddFileInfo(nsIDOMBlob* aBlob, FileInfo* aFileInfo);
 173
 174   void ClearCreatedFileInfos();
 175
 176   void
 177   SetActor(IndexedDBTransactionChild* aActorChild)
 178   {
 179     NS_ASSERTION(!aActorChild || !mActorChild, "Shouldn't have more than one!");
 180     mActorChild = aActorChild;
 181   }
 182
 183   void
 184   SetActor(IndexedDBTransactionParent* aActorParent)
 185   {
 186     NS_ASSERTION(!aActorParent || !mActorParent,
 187                  "Shouldn't have more than one!");
 188     mActorParent = aActorParent;
 189   }
 190
 191   IndexedDBTransactionChild*
 192   GetActorChild() const
 193   {
 194     return mActorChild;
 195   }
 196
 197   IndexedDBTransactionParent*
 198   GetActorParent() const
 199   {
 200     return mActorParent;
 201   }
 202
 203   nsresult
 204   Abort(IDBRequest* aRequest);
 205
 206   nsresult
 207   Abort(nsresult aAbortCode);
 208
 209   nsresult
 210   GetAbortCode() const
 211   {
 212     return mAbortCode;
 213   }
 214
 215 #ifdef MOZ_ENABLE_PROFILER_SPS
 216   uint64_t
 217   GetSerialNumber() const
 218   {
 219     return mSerialNumber;
 220   }
 221 #endif
 222
 223   // nsWrapperCache
 224   virtual JSObject*
 225   WrapObject(JSContext* aCx) MOZ_OVERRIDE;
 226
 227   // WebIDL
 228   nsPIDOMWindow*
 229   GetParentObject() const
 230   {
 231     return GetOwner();
 232   }
 233
 234   IDBTransactionMode
 235   GetMode(ErrorResult& aRv) const;
 236
 237   IDBDatabase*
 238   Db() const
 239   {
 240     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 241     return mDatabase;
 242   }
 243
 244   DOMError*
 245   GetError() const;
 246
 247   already_AddRefed<IDBObjectStore>
 248   ObjectStore(const nsAString& aName, ErrorResult& aRv);
 249
 250   void
 251   Abort(ErrorResult& aRv)
 252   {
 253     NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 254     aRv = AbortInternal(NS_ERROR_DOM_INDEXEDDB_ABORT_ERR, nullptr);
 255   }
 256
 257   IMPL_EVENT_HANDLER(abort)
 258   IMPL_EVENT_HANDLER(complete)
 259   IMPL_EVENT_HANDLER(error)
 260
 261   already_AddRefed<DOMStringList>
 262   GetObjectStoreNames(ErrorResult& aRv);
 263
 264 private:
 265   nsresult
 266   AbortInternal(nsresult aAbortCode,
 267                 already_AddRefed<mozilla::dom::DOMError> aError);
 268
 269   // Should only be called directly through IndexedDBDatabaseChild.
 270   static already_AddRefed<IDBTransaction>
 271   CreateInternal(IDBDatabase* aDatabase,
 272                  const Sequence<nsString>& aObjectStoreNames,
 273                  Mode aMode,
 274                  bool aDispatchDelayed,
 275                  bool aIsVersionChangeTransactionChild);
 276
 277   explicit IDBTransaction(IDBDatabase* aDatabase);
 278   ~IDBTransaction();
 279
 280   nsresult CommitOrRollback();
 281
 282   nsRefPtr<IDBDatabase> mDatabase;
 283   nsRefPtr<DatabaseInfo> mDatabaseInfo;
 284   nsRefPtr<DOMError> mError;
 285   nsTArray<nsString> mObjectStoreNames;
 286   ReadyState mReadyState;
 287   Mode mMode;
 288   uint32_t mPendingRequests;
 289
 290   nsInterfaceHashtable<nsCStringHashKey, mozIStorageStatement>
 291     mCachedStatements;
 292
 293   nsRefPtr<IDBTransactionListener> mListener;
 294
 295   // Only touched on the database thread.
 296   nsCOMPtr<mozIStorageConnection> mConnection;
 297
 298   // Only touched on the database thread.
 299   uint32_t mSavepointCount;
 300
 301   nsTArray<nsRefPtr<IDBObjectStore> > mCreatedObjectStores;
 302   nsTArray<nsRefPtr<IDBObjectStore> > mDeletedObjectStores;
 303
 304   nsRefPtr<UpdateRefcountFunction> mUpdateFileRefcountFunction;
 305   nsRefPtrHashtable<nsISupportsHashKey, FileInfo> mCreatedFileInfos;
 306
 307   IndexedDBTransactionChild* mActorChild;
 308   IndexedDBTransactionParent* mActorParent;
 309
 310   nsresult mAbortCode;
 311 #ifdef MOZ_ENABLE_PROFILER_SPS
 312   uint64_t mSerialNumber;
 313 #endif
 314   bool mCreating;
 315
 316 #ifdef DEBUG
 317   bool mFiredCompleteOrAbort;
 318 #endif
 319 };
 320
 321 class CommitHelper MOZ_FINAL : public nsIRunnable
 322 {
 323 public:
 324   NS_DECL_THREADSAFE_ISUPPORTS
 325   NS_DECL_NSIRUNNABLE
 326
 327   CommitHelper(IDBTransaction* aTransaction,
 328                IDBTransactionListener* aListener,
 329                const nsTArray<nsRefPtr<IDBObjectStore> >& mUpdatedObjectStores);
 330   CommitHelper(IDBTransaction* aTransaction,
 331                nsresult aAbortCode);
 332
 333   template<class T>
 334   bool AddDoomedObject(nsCOMPtr<T>& aCOMPtr)
 335   {
 336     if (aCOMPtr) {
 337       if (!mDoomedObjects.AppendElement(do_QueryInterface(aCOMPtr))) {
 338         NS_ERROR("Out of memory!");
 339         return false;
 340       }
 341       aCOMPtr = nullptr;
 342     }
 343     return true;
 344   }
 345
 346 private:
 347   ~CommitHelper();
 348
 349   // Writes new autoincrement counts to database
 350   nsresult WriteAutoIncrementCounts();
 351
 352   // Updates counts after a successful commit
 353   void CommitAutoIncrementCounts();
 354
 355   // Reverts counts when a transaction is aborted
 356   void RevertAutoIncrementCounts();
 357
 358   nsRefPtr<IDBTransaction> mTransaction;
 359   nsRefPtr<IDBTransactionListener> mListener;
 360   nsCOMPtr<mozIStorageConnection> mConnection;
 361   nsRefPtr<UpdateRefcountFunction> mUpdateFileRefcountFunction;
 362   nsAutoTArray<nsCOMPtr<nsISupports>, 10> mDoomedObjects;
 363   nsAutoTArray<nsRefPtr<IDBObjectStore>, 10> mAutoIncrementObjectStores;
 364
 365   nsresult mAbortCode;
 366 };
 367
 368 class UpdateRefcountFunction MOZ_FINAL : public mozIStorageFunction
 369 {
 370   ~UpdateRefcountFunction()
 371   { }
 372
 373 public:
 374   NS_DECL_THREADSAFE_ISUPPORTS
 375   NS_DECL_MOZISTORAGEFUNCTION
 376
 377   explicit UpdateRefcountFunction(FileManager* aFileManager)
 378   : mFileManager(aFileManager), mInSavepoint(false)
 379   { }
 380
 381   void StartSavepoint()
 382   {
 383     MOZ_ASSERT(!mInSavepoint);
 384     MOZ_ASSERT(!mSavepointEntriesIndex.Count());
 385
 386     mInSavepoint = true;
 387   }
 388
 389   void ReleaseSavepoint()
 390   {
 391     MOZ_ASSERT(mInSavepoint);
 392
 393     mSavepointEntriesIndex.Clear();
 394
 395     mInSavepoint = false;
 396   }
 397
 398   void RollbackSavepoint()
 399   {
 400     MOZ_ASSERT(mInSavepoint);
 401
 402     mInSavepoint = false;
 403
 404     mSavepointEntriesIndex.EnumerateRead(RollbackSavepointCallback, nullptr);
 405
 406     mSavepointEntriesIndex.Clear();
 407   }
 408
 409   void ClearFileInfoEntries()
 410   {
 411     mFileInfoEntries.Clear();
 412   }
 413
 414   nsresult WillCommit(mozIStorageConnection* aConnection);
 415   void DidCommit();
 416   void DidAbort();
 417
 418 private:
 419   class FileInfoEntry
 420   {
 421   public:
 422     explicit FileInfoEntry(FileInfo* aFileInfo)
 423     : mFileInfo(aFileInfo), mDelta(0), mSavepointDelta(0)
 424     { }
 425
 426     ~FileInfoEntry()
 427     { }
 428
 429     nsRefPtr<FileInfo> mFileInfo;
 430     int32_t mDelta;
 431     int32_t mSavepointDelta;
 432   };
 433
 434   enum UpdateType {
 435     eIncrement,
 436     eDecrement
 437   };
 438
 439   class DatabaseUpdateFunction
 440   {
 441   public:
 442     DatabaseUpdateFunction(mozIStorageConnection* aConnection,
 443                            UpdateRefcountFunction* aFunction)
 444     : mConnection(aConnection), mFunction(aFunction), mErrorCode(NS_OK)
 445     { }
 446
 447     bool Update(int64_t aId, int32_t aDelta);
 448     nsresult ErrorCode()
 449     {
 450       return mErrorCode;
 451     }
 452
 453   private:
 454     nsresult UpdateInternal(int64_t aId, int32_t aDelta);
 455
 456     nsCOMPtr<mozIStorageConnection> mConnection;
 457     nsCOMPtr<mozIStorageStatement> mUpdateStatement;
 458     nsCOMPtr<mozIStorageStatement> mSelectStatement;
 459     nsCOMPtr<mozIStorageStatement> mInsertStatement;
 460
 461     UpdateRefcountFunction* mFunction;
 462
 463     nsresult mErrorCode;
 464   };
 465
 466   nsresult ProcessValue(mozIStorageValueArray* aValues,
 467                         int32_t aIndex,
 468                         UpdateType aUpdateType);
 469
 470   nsresult CreateJournals();
 471
 472   nsresult RemoveJournals(const nsTArray<int64_t>& aJournals);
 473
 474   static PLDHashOperator
 475   DatabaseUpdateCallback(const uint64_t& aKey,
 476                          FileInfoEntry* aValue,
 477                          void* aUserArg);
 478
 479   static PLDHashOperator
 480   FileInfoUpdateCallback(const uint64_t& aKey,
 481                          FileInfoEntry* aValue,
 482                          void* aUserArg);
 483
 484   static PLDHashOperator
 485   RollbackSavepointCallback(const uint64_t& aKey,
 486                             FileInfoEntry* aValue,
 487                             void* aUserArg);
 488
 489   FileManager* mFileManager;
 490   nsClassHashtable<nsUint64HashKey, FileInfoEntry> mFileInfoEntries;
 491   nsDataHashtable<nsUint64HashKey, FileInfoEntry*> mSavepointEntriesIndex;
 492
 493   nsTArray<int64_t> mJournalsToCreateBeforeCommit;
 494   nsTArray<int64_t> mJournalsToRemoveAfterCommit;
 495   nsTArray<int64_t> mJournalsToRemoveAfterAbort;
 496
 497   bool mInSavepoint;
 498 };
 499
 500 END_INDEXEDDB_NAMESPACE
 501
 502 #endif // mozilla_dom_indexeddb_idbtransaction_h__